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 
22 using namespace testing;
23 using namespace testing::ext;
24 namespace OHOS::Rosen {
25 using Mocker = SingletonMocker<WindowAdapterLite, MockWindowAdapterLite>;
26 
27 class TestCameraWindowChangedListener : public ICameraWindowChangedListener {
28 public:
OnCameraWindowChange(uint32_t accessTokenId,bool isShowing)29     void OnCameraWindowChange(uint32_t accessTokenId, bool isShowing) override {};
30 };
31 
32 class TestWindowModeChangedListener : public IWindowModeChangedListener {
33 public:
OnWindowModeUpdate(WindowModeType mode)34     void OnWindowModeUpdate(WindowModeType mode) override {};
35 };
36 
37 class TestWMSConnectionChangedListener : public IWMSConnectionChangedListener {
38 public:
OnConnected(int32_t userId,int32_t screenId)39     void OnConnected(int32_t userId, int32_t screenId) override {};
OnDisconnected(int32_t userId,int32_t screenId)40     void OnDisconnected(int32_t userId, int32_t screenId) override {};
41 };
42 
43 class TestFocusChangedListener : public IFocusChangedListener {
44 public:
OnFocused(const sptr<FocusChangeInfo> & focusChangeInfo)45     void OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo) override {};
OnUnfocused(const sptr<FocusChangeInfo> & focusChangeInfo)46     void OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo) override {};
47 };
48 
49 class TestDrawingContentChangedListener : public IDrawingContentChangedListener {
50 public:
OnWindowDrawingContentChanged(const std::vector<sptr<WindowDrawingContentInfo>> & windowDrawingInfo)51     void OnWindowDrawingContentChanged(
52         const std::vector<sptr<WindowDrawingContentInfo>>& windowDrawingInfo) override {};
53 };
54 
55 class TestVisibilityChangedListener : public IVisibilityChangedListener {
56 public:
OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>> & windowVisibilityInfo)57     void OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfo) override {};
58 };
59 
60 class IWMSConnectionChangedListenerSon : public IWMSConnectionChangedListener {
61 public:
OnConnected(int32_t userId,int32_t screenId)62     void OnConnected(int32_t userId, int32_t screenId) override {};
OnDisconnected(int32_t userId,int32_t screenId)63     void OnDisconnected(int32_t userId, int32_t screenId) override {};
64 };
65 
66 class TestWindowStyleChangedListener : public IWindowStyleChangedListener {
67 public:
OnWindowStyleUpdate(WindowStyleType styleType)68     void OnWindowStyleUpdate(WindowStyleType styleType)
69     {
70         TLOGI(WmsLogTag::DMS, "TestWindowStyleChangedListener");
71     }
72 };
73 
74 class TestWindowUpdateListener : public IWindowUpdateListener {
75 public:
OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>> & infos,WindowUpdateType type)76     void OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>>& infos, WindowUpdateType type) override
77     {
78         WLOGI("TestWindowUpdateListener");
79     }
80 };
81 
82 class TestPiPStateChangedListener : public IPiPStateChangedListener {
83 public:
OnPiPStateChanged(const std::string & bundleName,bool isForeground)84     void OnPiPStateChanged(const std::string& bundleName, bool isForeground) override {}
85 };
86 
87 class WindowManagerLiteTest : public testing::Test {
88 public:
89     static void SetUpTestCase();
90     static void TearDownTestCase();
91     void SetUp() override;
92     void TearDown() override;
93 };
94 
SetUpTestCase()95 void WindowManagerLiteTest::SetUpTestCase()
96 {
97 }
98 
TearDownTestCase()99 void WindowManagerLiteTest::TearDownTestCase()
100 {
101 }
102 
SetUp()103 void WindowManagerLiteTest::SetUp()
104 {
105 }
106 
TearDown()107 void WindowManagerLiteTest::TearDown()
108 {
109 }
110 
111 namespace {
112 /**
113  * @tc.name: GetFocusWindowInfo
114  * @tc.desc: using windowManagerLite to get focus info
115  * @tc.type: FUNC
116  */
117 HWTEST_F(WindowManagerLiteTest, GetFocusWindowInfo, Function | SmallTest | Level2)
118 {
119     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
120     FocusChangeInfo infosInput;
121     FocusChangeInfo infosResult;
122     infosResult.pid_ = 10;
123     infosResult.uid_ = 11;
124     infosResult.displayId_ = 12;
125     infosResult.windowId_ = 13;
126     EXPECT_CALL(m->Mock(), GetFocusWindowInfo(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(infosResult), Return()));
127     WindowManagerLite::GetInstance().GetFocusWindowInfo(infosInput);
128     ASSERT_EQ(infosInput.windowId_, infosResult.windowId_);
129     ASSERT_EQ(infosInput.uid_, infosResult.uid_);
130     ASSERT_EQ(infosInput.pid_, infosResult.pid_);
131     ASSERT_EQ(infosInput.displayId_, infosResult.displayId_);
132 }
133 
134 /**
135  * @tc.name: UpdateCameraWindowStatus01
136  * @tc.desc: UpdateCameraWindowStatus
137  * @tc.type: FUNC
138  */
139 HWTEST_F(WindowManagerLiteTest, UpdateCameraWindowStatus01, Function | SmallTest | Level2)
140 {
141     uint32_t accessTokenId = 0;
142     bool isShowing = true;
143     auto ret = 0;
144     WindowManagerLite::GetInstance().UpdateCameraWindowStatus(accessTokenId, isShowing);
145     ASSERT_EQ(0, ret);
146 }
147 
148 /**
149  * @tc.name: UpdateCameraWindowStatus02
150  * @tc.desc: UpdateCameraWindowStatus
151  * @tc.type: FUNC
152  */
153 HWTEST_F(WindowManagerLiteTest, UpdateCameraWindowStatus02, Function | SmallTest | Level2)
154 {
155     auto& windowManager = WindowManagerLite::GetInstance();
156     sptr<TestCameraWindowChangedListener> listener = new (std::nothrow) TestCameraWindowChangedListener();
157     ASSERT_TRUE(listener != nullptr);
158     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
159     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
160     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraWindowChangedListener(listener));
161 
162     uint32_t accessTokenId = 0;
163     bool isShowing = true;
164     auto ret = 0;
165     WindowManagerLite::GetInstance().UpdateCameraWindowStatus(accessTokenId, isShowing);
166     ASSERT_EQ(0, ret);
167 }
168 
169 /**
170  * @tc.name: RegisterCameraWindowChangedListener01
171  * @tc.desc: check RegisterCameraWindowChangedListener
172  * @tc.type: FUNC
173  */
174 HWTEST_F(WindowManagerLiteTest, RegisterCameraWindowChangedListener01, Function | SmallTest | Level2)
175 {
176     auto& windowManager = WindowManagerLite::GetInstance();
177     auto oldWindowManagerAgent = windowManager.pImpl_->cameraWindowChangedListenerAgent_;
178     auto oldListeners = windowManager.pImpl_->cameraWindowChangedListeners_;
179     windowManager.pImpl_->cameraWindowChangedListenerAgent_ = nullptr;
180     windowManager.pImpl_->cameraWindowChangedListeners_.clear();
181     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraWindowChangedListener(nullptr));
182 
183     sptr<TestCameraWindowChangedListener> listener = new TestCameraWindowChangedListener();
184     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
185     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
186     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterCameraWindowChangedListener(listener));
187 
188     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
189     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraWindowChangedListener(listener));
190     ASSERT_EQ(1, windowManager.pImpl_->cameraWindowChangedListeners_.size());
191 
192     // to check that the same listner can not be registered twice
193     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
194     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterCameraWindowChangedListener(listener));
195     ASSERT_EQ(1, windowManager.pImpl_->cameraWindowChangedListeners_.size());
196 
197     windowManager.pImpl_->cameraWindowChangedListenerAgent_ = oldWindowManagerAgent;
198     windowManager.pImpl_->cameraWindowChangedListeners_ = oldListeners;
199 }
200 
201 /**
202  * @tc.name: UnregisterCameraWindowChangedListener01
203  * @tc.desc: check UnregisterCameraWindowChangedListener
204  * @tc.type: FUNC
205  */
206 HWTEST_F(WindowManagerLiteTest, UnregisterCameraWindowChangedListener01, Function | SmallTest | Level2)
207 {
208     auto& windowManager = WindowManagerLite::GetInstance();
209     auto oldWindowManagerAgent = windowManager.pImpl_->cameraWindowChangedListenerAgent_;
210     auto oldListeners = windowManager.pImpl_->cameraWindowChangedListeners_;
211     windowManager.pImpl_->cameraWindowChangedListenerAgent_ = nullptr;
212     windowManager.pImpl_->cameraWindowChangedListeners_.clear();
213 
214     // check nullpter
215     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterCameraWindowChangedListener(nullptr));
216 
217     sptr<TestCameraWindowChangedListener> listener1 = new TestCameraWindowChangedListener();
218     sptr<TestCameraWindowChangedListener> listener2 = new TestCameraWindowChangedListener();
219     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener1));
220 
221     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
222     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
223     windowManager.RegisterCameraWindowChangedListener(listener1);
224     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
225     windowManager.RegisterCameraWindowChangedListener(listener2);
226     ASSERT_EQ(2, windowManager.pImpl_->cameraWindowChangedListeners_.size());
227     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener1));
228 
229     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
230     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener2));
231     ASSERT_EQ(0, windowManager.pImpl_->cameraWindowChangedListeners_.size());
232     ASSERT_EQ(nullptr, windowManager.pImpl_->cameraWindowChangedListenerAgent_);
233 
234     windowManager.pImpl_->cameraWindowChangedListeners_.emplace_back(listener1);
235     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterCameraWindowChangedListener(listener1));
236     ASSERT_EQ(0, windowManager.pImpl_->cameraWindowChangedListeners_.size());
237 
238     windowManager.pImpl_->cameraWindowChangedListenerAgent_ = oldWindowManagerAgent;
239     windowManager.pImpl_->cameraWindowChangedListeners_ = oldListeners;
240 }
241 
242 /**
243  * @tc.name: Test01
244  * @tc.desc: check UnregisterCameraWindowChangedListener
245  * @tc.type: FUNC
246  */
247 HWTEST_F(WindowManagerLiteTest, Test01, Function | SmallTest | Level2)
248 {
249     sptr<IFocusChangedListener> listener = nullptr;
250     auto ret1 = WindowManagerLite::GetInstance().RegisterFocusChangedListener(listener);
251     auto ret2 = WindowManagerLite::GetInstance().UnregisterFocusChangedListener(listener);
252     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret1);
253     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret2);
254     sptr<IVisibilityChangedListener> listener1 = nullptr;
255     auto ret3 = WindowManagerLite::GetInstance().RegisterVisibilityChangedListener(listener1);
256     auto ret4 = WindowManagerLite::GetInstance().UnregisterVisibilityChangedListener(listener1);
257     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret3);
258     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret4);
259     std::vector<sptr<WindowVisibilityInfo>> infos;
260     ASSERT_EQ(WMError::WM_OK, WindowManagerLite::GetInstance().GetVisibilityWindowInfo(infos));
261     sptr<IDrawingContentChangedListener> listener2 = nullptr;
262     auto ret5 = WindowManagerLite::GetInstance().RegisterDrawingContentChangedListener(listener2);
263     auto ret6 = WindowManagerLite::GetInstance().UnregisterDrawingContentChangedListener(listener2);
264     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret5);
265     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret6);
266     sptr<IWindowModeChangedListener> listener3 = nullptr;
267     auto ret7 = WindowManagerLite::GetInstance().RegisterWindowModeChangedListener(listener3);
268     auto ret8 = WindowManagerLite::GetInstance().UnregisterWindowModeChangedListener(listener3);
269     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret7);
270     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, ret8);
271     sptr<IWMSConnectionChangedListener> listener4 = nullptr;
272     WMError res9 = WindowManagerLite::GetInstance().RegisterWMSConnectionChangedListener(listener4);
273     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, res9);
274     WMError res10 = WindowManagerLite::GetInstance().UnregisterWMSConnectionChangedListener();
275     ASSERT_EQ(WMError::WM_OK, res10);
276 }
277 
278 /**
279  * @tc.name: Test04
280  * @tc.desc: Test04
281  * @tc.type: FUNC
282  */
283 HWTEST_F(WindowManagerLiteTest, Test04, Function | SmallTest | Level2)
284 {
285     WindowManagerLite lite;
286     ASSERT_NE(lite.pImpl_, nullptr);
287     sptr<FocusChangeInfo> focusChangeInfo = nullptr;
288     lite.pImpl_->NotifyFocused(focusChangeInfo);
289     lite.pImpl_->NotifyUnfocused(focusChangeInfo);
290     focusChangeInfo = new FocusChangeInfo();
291     lite.pImpl_->NotifyFocused(focusChangeInfo);
292     lite.pImpl_->NotifyUnfocused(focusChangeInfo);
293     std::vector<sptr<WindowVisibilityInfo>> windowVisibilityInfos;
294     lite.pImpl_->NotifyWindowVisibilityInfoChanged(windowVisibilityInfos);
295     std::vector<sptr<WindowDrawingContentInfo>> windowDrawingContentInfos;
296     lite.pImpl_->NotifyWindowDrawingContentInfoChanged(windowDrawingContentInfos);
297     lite.pImpl_->NotifyWindowModeChange(WindowModeType::WINDOW_MODE_SPLIT);
298 }
299 
300 /**
301  * @tc.name: RegisterWindowModeChangedListener02
302  * @tc.desc: check RegisterWindowModeChangedListener
303  * @tc.type: FUNC
304  */
305 HWTEST_F(WindowManagerLiteTest, RegisterWindowModeChangedListener02, Function | SmallTest | Level2)
306 {
307     auto& windowManager = WindowManagerLite::GetInstance();
308     auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
309     auto oldListeners = windowManager.pImpl_->windowModeListeners_;
310     windowManager.pImpl_->windowModeListenerAgent_ = nullptr;
311     windowManager.pImpl_->windowModeListeners_.clear();
312     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(nullptr));
313 
314     sptr<TestWindowModeChangedListener> listener = new (std::nothrow) TestWindowModeChangedListener();
315     ASSERT_TRUE(listener != nullptr);
316     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
317     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
318     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowModeChangedListener(listener));
319 
320     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
321     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
322     ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
323 
324     // to check that the same listner can not be registered twice
325     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
326     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
327     ASSERT_EQ(1, windowManager.pImpl_->windowModeListeners_.size());
328 
329     windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
330     windowManager.pImpl_->windowModeListeners_ = oldListeners;
331 }
332 
333 /**
334  * @tc.name: UnregisterWindowModeChangedListener02
335  * @tc.desc: check UnregisterWindowModeChangedListener
336  * @tc.type: FUNC
337  */
338 HWTEST_F(WindowManagerLiteTest, UnregisterWindowModeChangedListener02, Function | SmallTest | Level2)
339 {
340     auto& windowManager = WindowManagerLite::GetInstance();
341     auto oldWindowManagerAgent = windowManager.pImpl_->windowModeListenerAgent_;
342     auto oldListeners = windowManager.pImpl_->windowModeListeners_;
343     windowManager.pImpl_->windowModeListenerAgent_ = nullptr;
344     windowManager.pImpl_->windowModeListeners_.clear();
345 
346     // check nullpter
347     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowModeChangedListener(nullptr));
348 
349     sptr<TestWindowModeChangedListener> listener1 = new (std::nothrow) TestWindowModeChangedListener();
350     ASSERT_TRUE(listener1 != nullptr);
351     sptr<TestWindowModeChangedListener> listener2 = new (std::nothrow) TestWindowModeChangedListener();
352     ASSERT_TRUE(listener2 != nullptr);
353     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
354 
355     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
356     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
357     windowManager.RegisterWindowModeChangedListener(listener1);
358     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
359     windowManager.RegisterWindowModeChangedListener(listener2);
360     ASSERT_EQ(2, windowManager.pImpl_->windowModeListeners_.size());
361     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
362 
363     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
364     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener2));
365     ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
366     ASSERT_EQ(nullptr, windowManager.pImpl_->windowModeListenerAgent_);
367 
368     windowManager.pImpl_->windowModeListeners_.emplace_back(listener1);
369     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowModeChangedListener(listener1));
370     ASSERT_EQ(0, windowManager.pImpl_->windowModeListeners_.size());
371 
372     windowManager.pImpl_->windowModeListenerAgent_ = oldWindowManagerAgent;
373     windowManager.pImpl_->windowModeListeners_ = oldListeners;
374 }
375 
376 /**
377  * @tc.name: RegisterWMSConnectionChangedListener02
378  * @tc.desc: check RegisterWMSConnectionChangedListener
379  * @tc.type: FUNC
380  */
381 HWTEST_F(WindowManagerLiteTest, RegisterWMSConnectionChangedListener02, Function | SmallTest | Level2)
382 {
383     auto& windowManager = WindowManagerLite::GetInstance();
384     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWMSConnectionChangedListener(nullptr));
385 
386     sptr<TestWMSConnectionChangedListener> listener = new (std::nothrow) TestWMSConnectionChangedListener();
387     ASSERT_TRUE(listener != nullptr);
388     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
389     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWMSConnectionChangedListener(listener));
390 
391     windowManager.pImpl_->wmsConnectionChangedListener_ = nullptr;
392     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWMSConnectionChangedListener(listener));
393 }
394 
395 /**
396  * @tc.name: GetMainWindowInfos
397  * @tc.desc: get top main window info
398  * @tc.type: FUNC
399  */
400 HWTEST_F(WindowManagerLiteTest, GetMainWindowInfos, Function | SmallTest | Level2)
401 {
402     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
403     std::vector<MainWindowInfo> topNInfo;
404     std::vector<MainWindowInfo> topNInfoResult;
405     MainWindowInfo info1;
406     info1.pid_ = 1900;
407     info1.bundleName_ = "calendar";
408 
409     MainWindowInfo info2;
410     info1.pid_ = 1901;
411     info1.bundleName_ = "settings";
412 
413     MainWindowInfo info3;
414     info1.pid_ = 1902;
415     info1.bundleName_ = "photos";
416 
417     topNInfoResult.push_back(info1);
418     topNInfoResult.push_back(info2);
419     topNInfoResult.push_back(info3);
420 
421     int32_t topN = 3;
422 
423     EXPECT_CALL(m->Mock(), GetMainWindowInfos(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<1>(topNInfoResult),
424         Return(WMError::WM_OK)));
425 
426     WindowManagerLite::GetInstance().GetMainWindowInfos(topN, topNInfo);
427 
428     auto it1 = topNInfo.begin();
429     auto it2 = topNInfoResult.begin();
430     for (; it1 != topNInfo.end() && it2 != topNInfoResult.end(); it1++, it2++) {
431         ASSERT_EQ(it1->pid_, it2->pid_);
432         ASSERT_EQ(it1->bundleName_, it2->bundleName_);
433     }
434 }
435 
436 /**
437  * @tc.name: GetWindowModeType
438  * @tc.desc: GetWindowModeType
439  * @tc.type: FUNC
440  */
441 HWTEST_F(WindowManagerLiteTest, GetWindowModeType, Function | SmallTest | Level2)
442 {
443     WindowModeType windowModeType = WindowModeType::WINDOW_MODE_SPLIT_FLOATING;
444     auto ret = WindowManagerLite::GetInstance().GetWindowModeType(windowModeType);
445     ASSERT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
446 }
447 
448 /**
449  * @tc.name: NotifyFocusedWithUn
450  * @tc.desc: NotifyFocused With MotifyUnFocused
451  * @tc.type: FUNC
452  */
453 HWTEST_F(WindowManagerLiteTest, NotifyFocusedWithUn, Function | SmallTest | Level2)
454 {
455     WindowManagerLite lite;
456     sptr<FocusChangeInfo> focusChangeInfo = nullptr;
457     lite.pImpl_->NotifyFocused(focusChangeInfo);
458     lite.pImpl_->NotifyUnfocused(focusChangeInfo);
459     ASSERT_EQ(focusChangeInfo, nullptr);
460     focusChangeInfo = new (std::nothrow) FocusChangeInfo();
461     lite.pImpl_->focusChangedListeners_.push_back(nullptr);
462     sptr<TestFocusChangedListener> testFocusChangedListener = new (std::nothrow) TestFocusChangedListener();
463     lite.pImpl_->focusChangedListeners_.push_back(testFocusChangedListener);
464     lite.pImpl_->NotifyFocused(focusChangeInfo);
465     lite.pImpl_->NotifyUnfocused(focusChangeInfo);
466     ASSERT_NE(focusChangeInfo, nullptr);
467 }
468 
469 /**
470  * @tc.name: NotifyWindowDrawingContentInfoChanged02
471  * @tc.desc: NotifyWindowDrawingContentInfoChanged
472  * @tc.type: FUNC
473  */
474 HWTEST_F(WindowManagerLiteTest, NotifyWindowDrawingContentInfoChanged02, Function | SmallTest | Level2)
475 {
476     WindowManagerLite lite;
477     auto& windowManager = WindowManagerLite::GetInstance();
478     sptr<TestDrawingContentChangedListener> listener = new (std::nothrow) TestDrawingContentChangedListener();
479     ASSERT_TRUE(listener != nullptr);
480     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
481     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
482     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterDrawingContentChangedListener(listener));
483 
484     std::vector<sptr<WindowDrawingContentInfo>> windowDrawingContentInfos;
485     lite.pImpl_->NotifyWindowDrawingContentInfoChanged(windowDrawingContentInfos);
486 }
487 
488 /**
489  * @tc.name: NotifyWindowModeChange02
490  * @tc.desc: NotifyWindowModeChange
491  * @tc.type: FUNC
492  */
493 HWTEST_F(WindowManagerLiteTest, NotifyWindowModeChange02, Function | SmallTest | Level2)
494 {
495     WindowManagerLite lite;
496     auto& windowManager = WindowManagerLite::GetInstance();
497     sptr<TestWindowModeChangedListener> listener = new (std::nothrow) TestWindowModeChangedListener();
498     ASSERT_TRUE(listener != nullptr);
499     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
500     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
501     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowModeChangedListener(listener));
502 
503     lite.pImpl_->NotifyWindowModeChange(WindowModeType::WINDOW_MODE_SPLIT);
504 }
505 
506 /**
507  * @tc.name: NotifyWindowVisibilityInfoChanged02
508  * @tc.desc: NotifyWindowVisibilityInfoChanged
509  * @tc.type: FUNC
510  */
511 HWTEST_F(WindowManagerLiteTest, NotifyWindowVisibilityInfoChanged02, Function | SmallTest | Level2)
512 {
513     WindowManagerLite lite;
514     auto& windowManager = WindowManagerLite::GetInstance();
515     sptr<TestVisibilityChangedListener> listener = new (std::nothrow) TestVisibilityChangedListener();
516     ASSERT_TRUE(listener != nullptr);
517     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
518     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
519     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterVisibilityChangedListener(listener));
520 
521     std::vector<sptr<WindowVisibilityInfo>> windowVisibilityInfos;
522     lite.pImpl_->NotifyWindowVisibilityInfoChanged(windowVisibilityInfos);
523 }
524 
525 /**
526  * @tc.name: NotifyUnfocused01
527  * @tc.desc: NotifyUnfocused
528  * @tc.type: FUNC
529  */
530 HWTEST_F(WindowManagerLiteTest, NotifyUnfocused01, Function | SmallTest | Level2)
531 {
532     WindowManagerLite lite;
533     auto& windowManager = WindowManagerLite::GetInstance();
534     sptr<FocusChangeInfo> focusChangeInfo = new (std::nothrow) FocusChangeInfo();
535     ASSERT_TRUE(focusChangeInfo != nullptr);
536 
537     sptr<TestFocusChangedListener> listener = new (std::nothrow) TestFocusChangedListener();
538     ASSERT_TRUE(listener != nullptr);
539     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
540     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
541     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterFocusChangedListener(listener));
542     lite.pImpl_->NotifyUnfocused(focusChangeInfo);
543 }
544 
545 /**
546  * @tc.name: GetAllMainWindowInfos001
547  * @tc.desc: GetAllMainWindowInfos001
548  * @tc.type: FUNC
549  */
550 HWTEST_F(WindowManagerLiteTest, GetAllMainWindowInfos001, Function | SmallTest | Level2)
551 {
552     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
553     std::vector<MainWindowInfo> infos;
554     std::vector<MainWindowInfo> infosResult;
555     MainWindowInfo info1;
556     info1.pid_ = 1900;
557     info1.bundleName_ = "calendar";
558 
559     MainWindowInfo info2;
560     info1.pid_ = 1901;
561     info1.bundleName_ = "settings";
562 
563     MainWindowInfo info3;
564     info1.pid_ = 1902;
565     info1.bundleName_ = "photos";
566 
567     infosResult.push_back(info1);
568     infosResult.push_back(info2);
569     infosResult.push_back(info3);
570 
571     EXPECT_CALL(m->Mock(), GetAllMainWindowInfos(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(infosResult),
572         Return(WMError::WM_OK)));
573 
574     auto errorCode = WindowManagerLite::GetInstance().GetAllMainWindowInfos(infos);
575     ASSERT_EQ(WMError::WM_OK, errorCode);
576     auto it1 = infos.begin();
577     auto it2 = infosResult.begin();
578     for (; it1 != infos.end() && it2 != infosResult.end(); it1++, it2++) {
579         ASSERT_EQ(it1->pid_, it2->pid_);
580         ASSERT_EQ(it1->bundleName_, it2->bundleName_);
581         ASSERT_EQ(it1->persistentId_, it2->persistentId_);
582         ASSERT_EQ(it1->bundleType_, it2->bundleType_);
583     }
584 }
585 
586 /**
587  * @tc.name: GetAllMainWindowInfos002
588  * @tc.desc: GetAllMainWindowInfos002
589  * @tc.type: FUNC
590  */
591 HWTEST_F(WindowManagerLiteTest, GetAllMainWindowInfos002, Function | SmallTest | Level2)
592 {
593     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
594     std::vector<MainWindowInfo> infos;
595     MainWindowInfo info1;
596     info1.pid_ = 1900;
597     info1.bundleName_ = "calendar";
598     infos.push_back(info1);
599 
600     EXPECT_CALL(m->Mock(), GetAllMainWindowInfos(_)).Times(0).WillOnce(DoAll(Return(WMError::WM_OK)));
601 
602     auto errorCode = WindowManagerLite::GetInstance().GetAllMainWindowInfos(infos);
603     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, errorCode);
604 }
605 
606 /**
607  * @tc.name: ClearMainSessions001
608  * @tc.desc: ClearMainSessions001
609  * @tc.type: FUNC
610  */
611 HWTEST_F(WindowManagerLiteTest, ClearMainSessions001, Function | SmallTest | Level2)
612 {
613     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
614     std::vector<int32_t> persistentIds;
615 
616     EXPECT_CALL(m->Mock(), ClearMainSessions(_)).Times(0).WillOnce(Return(WMError::WM_OK));
617 
618     auto errorCode = WindowManagerLite::GetInstance().ClearMainSessions(persistentIds);
619     ASSERT_EQ(WMError::WM_OK, errorCode);
620 }
621 
622 /**
623  * @tc.name: ClearMainSessions002
624  * @tc.desc: ClearMainSessions002
625  * @tc.type: FUNC
626  */
627 HWTEST_F(WindowManagerLiteTest, ClearMainSessions002, Function | SmallTest | Level2)
628 {
629     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
630     std::vector<int32_t> persistentIds = { 1, 2 };
631 
632     EXPECT_CALL(m->Mock(), ClearMainSessions(_)).Times(1).WillOnce(Return(WMError::WM_OK));
633 
634     auto errorCode = WindowManagerLite::GetInstance().ClearMainSessions(persistentIds);
635     ASSERT_EQ(WMError::WM_OK, errorCode);
636 }
637 
638 /**
639  * @tc.name: ClearMainSessions003
640  * @tc.desc: ClearMainSessions003
641  * @tc.type: FUNC
642  */
643 HWTEST_F(WindowManagerLiteTest, ClearMainSessions003, Function | SmallTest | Level2)
644 {
645     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
646     std::vector<int32_t> persistentIds;
647     std::vector<int32_t> clearFailedIds;
648     EXPECT_CALL(m->Mock(), ClearMainSessions(_, _)).Times(0).WillOnce(Return(WMError::WM_OK));
649 
650     auto errorCode = WindowManagerLite::GetInstance().ClearMainSessions(persistentIds, clearFailedIds);
651     ASSERT_EQ(WMError::WM_OK, errorCode);
652 }
653 
654 /**
655  * @tc.name: ClearMainSessions004
656  * @tc.desc: ClearMainSessions004
657  * @tc.type: FUNC
658  */
659 HWTEST_F(WindowManagerLiteTest, ClearMainSessions004, Function | SmallTest | Level2)
660 {
661     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
662     std::vector<int32_t> persistentIds = { 1, 2 };
663     std::vector<int32_t> clearFailedIds;
664     EXPECT_CALL(m->Mock(), ClearMainSessions(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
665 
666     auto errorCode = WindowManagerLite::GetInstance().ClearMainSessions(persistentIds, clearFailedIds);
667     ASSERT_EQ(WMError::WM_OK, errorCode);
668 }
669 
670 /**
671  * @tc.name: RaiseWindowToTop
672  * @tc.desc: RaiseWindowToTop
673  * @tc.type: FUNC
674  */
675 HWTEST_F(WindowManagerLiteTest, RaiseWindowToTop, Function | SmallTest | Level2)
676 {
677     auto ret = WindowManagerLite::GetInstance().RaiseWindowToTop(0);
678     EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
679 }
680 
681 /**
682  * @tc.name: NotifyWMSConnected01
683  * @tc.desc: NotifyWMSConnected
684  * @tc.type: FUNC
685  */
686 HWTEST_F(WindowManagerLiteTest, NotifyWMSConnected01, Function | SmallTest | Level2)
687 {
688     WindowManagerLite::GetInstance().pImpl_->wmsConnectionChangedListener_ = nullptr;
689     WindowManagerLite::GetInstance().pImpl_->NotifyWMSConnected(0, 0);
690     WindowManagerLite::GetInstance().pImpl_->NotifyWMSDisconnected(0, 0);
691     sptr<FocusChangeInfo> focusChangeInfo = nullptr;
692     WindowManagerLite::GetInstance().UpdateFocusChangeInfo(focusChangeInfo, true);
693     focusChangeInfo = sptr<FocusChangeInfo>::MakeSptr();
694     ASSERT_NE(nullptr, focusChangeInfo);
695     WindowManagerLite::GetInstance().UpdateFocusChangeInfo(focusChangeInfo, true);
696     WindowManagerLite::GetInstance().UpdateFocusChangeInfo(focusChangeInfo, false);
697     std::vector<sptr<WindowVisibilityInfo>> windowVisibilityInfos;
698     WindowManagerLite::GetInstance().UpdateWindowVisibilityInfo(windowVisibilityInfos);
699     std::vector<sptr<WindowDrawingContentInfo>> windowDrawingContentInfos;
700     WindowManagerLite::GetInstance().UpdateWindowDrawingContentInfo(windowDrawingContentInfos);
701     WindowManagerLite::GetInstance().OnRemoteDied();
702     WindowManagerLite::GetInstance().OnWMSConnectionChanged(0, 0, true);
703     WindowManagerLite::GetInstance().OnWMSConnectionChanged(0, 0, false);
704     WindowModeType windowModeType = WindowModeType::WINDOW_MODE_SPLIT_FLOATING;
705     WindowManagerLite::GetInstance().UpdateWindowModeTypeInfo(windowModeType);
706     auto ret = WindowManagerLite::GetInstance().GetWindowModeType(windowModeType);
707     EXPECT_EQ(WMError::WM_ERROR_INVALID_PERMISSION, ret);
708 }
709 
710 /**
711  * @tc.name: NotifyWMSConnected02
712  * @tc.desc: NotifyWMSConnected
713  * @tc.type: FUNC
714  */
715 HWTEST_F(WindowManagerLiteTest, NotifyWMSConnected02, Function | SmallTest | Level2)
716 {
717     auto& windowManager = WindowManagerLite::GetInstance();
718     sptr<TestWMSConnectionChangedListener> listener = new (std::nothrow) TestWMSConnectionChangedListener();
719     ASSERT_TRUE(listener != nullptr);
720     windowManager.pImpl_->wmsConnectionChangedListener_ = nullptr;
721     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
722     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWMSConnectionChangedListener(listener));
723     int32_t userId = 0;
724     int32_t screenId = 0;
725     WindowManagerLite::GetInstance().pImpl_->NotifyWMSConnected(userId, screenId);
726     WindowManagerLite::GetInstance().pImpl_->NotifyWMSDisconnected(userId, screenId);
727 }
728 
729 /**
730  * @tc.name: NotifyWMSConnected03
731  * @tc.desc: NotifyWMSConnected
732  * @tc.type: FUNC
733  */
734 HWTEST_F(WindowManagerLiteTest, NotifyWMSConnected03, Function | SmallTest | Level2)
735 {
736     WindowManagerLite::GetInstance().pImpl_->wmsConnectionChangedListener_ = new IWMSConnectionChangedListenerSon();
737     WindowManagerLite::GetInstance().pImpl_->NotifyWMSConnected(0, 0);
738     EXPECT_NE(WindowManagerLite::GetInstance().pImpl_->wmsConnectionChangedListener_, nullptr);
739     WindowManagerLite::GetInstance().pImpl_->NotifyWMSDisconnected(0, 0);
740     EXPECT_NE(WindowManagerLite::GetInstance().pImpl_->wmsConnectionChangedListener_, nullptr);
741 }
742 
743 /**
744  * @tc.name: RegisterWindowStyleChangedListener
745  * @tc.desc: check RegisterWindowStyleChangedListener
746  * @tc.type: FUNC
747  */
748 HWTEST_F(WindowManagerLiteTest, RegisterWindowStyleChangedListener, Function | SmallTest | Level2)
749 {
750     auto& windowManager = WindowManagerLite::GetInstance();
751     auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_;
752     auto oldListeners = windowManager.pImpl_->windowStyleListeners_;
753     windowManager.pImpl_->windowStyleListenerAgent_ = nullptr;
754     windowManager.pImpl_->windowStyleListeners_.clear();
755     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowStyleChangedListener(nullptr));
756 
757     sptr<IWindowStyleChangedListener> listener = new TestWindowStyleChangedListener();
758     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
759     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
760     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowStyleChangedListener(listener));
761     ASSERT_EQ(nullptr, windowManager.pImpl_->windowStyleListenerAgent_);
762 
763     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
764     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
765     ASSERT_EQ(1, windowManager.pImpl_->windowStyleListeners_.size());
766 
767     // to check that the same listner can not be registered twice
768     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
769     ASSERT_EQ(1, windowManager.pImpl_->windowStyleListeners_.size());
770 
771     windowManager.pImpl_->windowStyleListenerAgent_ = oldWindowManagerAgent;
772     windowManager.pImpl_->windowStyleListeners_ = oldListeners;
773 }
774 
775 /**
776  * @tc.name: UnregisterWindowStyleChangedListener
777  * @tc.desc: check UnregisterWindowStyleChangedListener
778  * @tc.type: FUNC
779  */
780 HWTEST_F(WindowManagerLiteTest, UnregisterWindowStyleChangedListener, Function | SmallTest | Level2)
781 {
782     auto& windowManager = WindowManagerLite::GetInstance();
783     auto oldWindowManagerAgent = windowManager.pImpl_->windowStyleListenerAgent_;
784     auto oldListeners = windowManager.pImpl_->windowStyleListeners_;
785     windowManager.pImpl_->windowStyleListenerAgent_ = new (std::nothrow) WindowManagerAgentLite();
786     windowManager.pImpl_->windowStyleListeners_.clear();
787     // check nullpter
788     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowStyleChangedListener(nullptr));
789 
790     sptr<TestWindowStyleChangedListener> listener1 = new TestWindowStyleChangedListener();
791     sptr<TestWindowStyleChangedListener> listener2 = new TestWindowStyleChangedListener();
792     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
793 
794     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
795     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
796     windowManager.RegisterWindowStyleChangedListener(listener1);
797     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
798     windowManager.RegisterWindowStyleChangedListener(listener2);
799     ASSERT_EQ(2, windowManager.pImpl_->windowStyleListeners_.size());
800 
801     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
802     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
803     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener2));
804     ASSERT_EQ(0, windowManager.pImpl_->windowStyleListeners_.size());
805     ASSERT_EQ(nullptr, windowManager.pImpl_->windowStyleListenerAgent_);
806 
807     windowManager.pImpl_->windowStyleListeners_.push_back(listener1);
808     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowStyleChangedListener(listener1));
809     ASSERT_EQ(0, windowManager.pImpl_->windowStyleListeners_.size());
810     windowManager.pImpl_->windowStyleListenerAgent_ = oldWindowManagerAgent;
811     windowManager.pImpl_->windowStyleListeners_ = oldListeners;
812 }
813 
814 /**
815  * @tc.name: NotifyWindowStyleChange01
816  * @tc.desc: check NotifyWindowStyleChange
817  * @tc.type: FUNC
818  */
819 HWTEST_F(WindowManagerLiteTest, NotifyWindowStyleChange01, Function | SmallTest | Level2)
820 {
821     WindowStyleType type = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT;
822     auto ret = WindowManagerLite::GetInstance().NotifyWindowStyleChange(type);
823     ASSERT_EQ(WMError::WM_OK, ret);
824 }
825 
826 /**
827  * @tc.name: NotifyWindowStyleChange02
828  * @tc.desc: check NotifyWindowStyleChange
829  * @tc.type: FUNC
830  */
831 HWTEST_F(WindowManagerLiteTest, NotifyWindowStyleChange02, Function | SmallTest | Level2)
832 {
833     auto& windowManager = WindowManagerLite::GetInstance();
834     sptr<IWindowStyleChangedListener> listener = new (std::nothrow) TestWindowStyleChangedListener();
835     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
836     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
837     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowStyleChangedListener(listener));
838 
839     WindowStyleType type = Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT;
840     auto ret = WindowManagerLite::GetInstance().NotifyWindowStyleChange(type);
841     ASSERT_EQ(WMError::WM_OK, ret);
842 }
843 
844 /**
845  * @tc.name: GetWindowStyleType
846  * @tc.desc: check GetWindowStyleType
847  * @tc.type: FUNC
848  */
849 HWTEST_F(WindowManagerLiteTest, GetWindowStyleType, Function | SmallTest | Level2)
850 {
851     WindowStyleType type = WindowManagerLite::GetInstance().GetWindowStyleType();
852     ASSERT_EQ(Rosen::WindowStyleType::WINDOW_STYLE_DEFAULT, type);
853 }
854 
855 /**
856  * @tc.name: TerminateSessionByPersistentId001
857  * @tc.desc: TerminateSessionByPersistentId001
858  * @tc.type: FUNC
859  */
860 HWTEST_F(WindowManagerLiteTest, TerminateSessionByPersistentId001, Function | SmallTest | Level2)
861 {
862     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
863     int32_t persistentId = 1;
864     EXPECT_CALL(m->Mock(), TerminateSessionByPersistentId(_)).Times(1).WillOnce(Return(WMError::WM_OK));
865 
866     auto errorCode = WindowManagerLite::GetInstance().TerminateSessionByPersistentId(persistentId);
867     ASSERT_EQ(WMError::WM_OK, errorCode);
868 }
869 
870 /**
871  * @tc.name: TerminateSessionByPersistentId002
872  * @tc.desc: TerminateSessionByPersistentId002
873  * @tc.type: FUNC
874  */
875 HWTEST_F(WindowManagerLiteTest, TerminateSessionByPersistentId002, Function | SmallTest | Level2)
876 {
877     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
878     int32_t persistentId = 0;
879 
880     auto errorCode = WindowManagerLite::GetInstance().TerminateSessionByPersistentId(persistentId);
881     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, errorCode);
882 }
883 
884 /**
885  * @tc.name: OnRemoteDied01
886  * @tc.desc: OnRemoteDied01
887  * @tc.type: FUNC
888  */
889 HWTEST_F(WindowManagerLiteTest, OnRemoteDied01, Function | SmallTest | Level2)
890 {
891     WindowManagerLite::GetInstance().destroyed_ = true;
892     WindowManagerLite::GetInstance().OnRemoteDied();
893     ASSERT_EQ(WindowManagerLite::GetInstance().destroyed_, true);
894 }
895 
896 /**
897  * @tc.name: GetAccessibilityWindowInfo01
898  * @tc.desc: check GetAccessibilityWindowInfo
899  * @tc.type: FUNC
900  */
901 HWTEST_F(WindowManagerLiteTest, GetAccessibilityWindowInfo01, Function | SmallTest | Level2)
902 {
903     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
904     std::vector<sptr<AccessibilityWindowInfo>> infos;
905     infos.clear();
906     EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
907     ASSERT_EQ(WMError::WM_OK, WindowManagerLite::GetInstance().GetAccessibilityWindowInfo(infos));
908     EXPECT_CALL(m->Mock(), GetAccessibilityWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW));
909     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, WindowManagerLite::GetInstance().GetAccessibilityWindowInfo(infos));
910 }
911 
912 /**
913  * @tc.name: RegisterWindowUpdateListener01
914  * @tc.desc: check RegisterWindowUpdateListener
915  * @tc.type: FUNC
916  */
917 HWTEST_F(WindowManagerLiteTest, RegisterWindowUpdateListener01, Function | SmallTest | Level2)
918 {
919     auto& windowManager = WindowManagerLite::GetInstance();
920     auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
921     auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
922     windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
923     windowManager.pImpl_->windowUpdateListeners_.clear();
924     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(nullptr));
925 
926     sptr<TestWindowUpdateListener> listener = new TestWindowUpdateListener();
927     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
928     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
929     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterWindowUpdateListener(listener));
930     ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
931 
932     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
933     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
934     ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
935 
936     // to check that the same listner can not be registered twice
937     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
938     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterWindowUpdateListener(listener));
939     ASSERT_EQ(1, windowManager.pImpl_->windowUpdateListeners_.size());
940 
941     windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
942     windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
943 }
944 
945 /**
946  * @tc.name: UnregisterWindowUpdateListener01
947  * @tc.desc: check UnregisterWindowUpdateListener
948  * @tc.type: FUNC
949  */
950 HWTEST_F(WindowManagerLiteTest, UnregisterWindowUpdateListener01, Function | SmallTest | Level2)
951 {
952     auto& windowManager = WindowManagerLite::GetInstance();
953     auto oldWindowManagerAgent = windowManager.pImpl_->windowUpdateListenerAgent_;
954     auto oldListeners = windowManager.pImpl_->windowUpdateListeners_;
955     windowManager.pImpl_->windowUpdateListenerAgent_ = nullptr;
956     windowManager.pImpl_->windowUpdateListeners_.clear();
957 
958     // check nullpter
959     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterWindowUpdateListener(nullptr));
960 
961     sptr<TestWindowUpdateListener> listener1 = new TestWindowUpdateListener();
962     sptr<TestWindowUpdateListener> listener2 = new TestWindowUpdateListener();
963     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
964 
965     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
966     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
967     windowManager.RegisterWindowUpdateListener(listener1);
968     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
969     windowManager.RegisterWindowUpdateListener(listener2);
970     ASSERT_EQ(2, windowManager.pImpl_->windowUpdateListeners_.size());
971 
972     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
973     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
974     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener2));
975     ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
976     ASSERT_EQ(nullptr, windowManager.pImpl_->windowUpdateListenerAgent_);
977 
978     windowManager.pImpl_->windowUpdateListeners_.emplace_back(listener1);
979     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterWindowUpdateListener(listener1));
980     ASSERT_EQ(0, windowManager.pImpl_->windowUpdateListeners_.size());
981 
982     windowManager.pImpl_->windowUpdateListenerAgent_ = oldWindowManagerAgent;
983     windowManager.pImpl_->windowUpdateListeners_ = oldListeners;
984 }
985 
986 /**
987  * @tc.name: CloseTargetFloatWindow
988  * @tc.desc: check CloseTargetFloatWindow
989  * @tc.type: FUNC
990  */
991 HWTEST_F(WindowManagerLiteTest, CloseTargetFloatWindow, Function | SmallTest | Level2)
992 {
993     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
994     std::string bundleName = "test";
995     EXPECT_CALL(m->Mock(), CloseTargetFloatWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
996 
997     auto errorCode = WindowManagerLite::GetInstance().CloseTargetFloatWindow(bundleName);
998     ASSERT_EQ(WMError::WM_OK, errorCode);
999 }
1000 
1001 /**
1002  * @tc.name: RegisterPiPStateChangedListener
1003  * @tc.desc: check RegisterPiPStateChangedListener
1004  * @tc.type: FUNC
1005  */
1006 HWTEST_F(WindowManagerLiteTest, RegisterPiPStateChangedListener, Function | SmallTest | Level2)
1007 {
1008     auto& windowManager = WindowManagerLite::GetInstance();
1009     auto oldWindowManagerAgent = windowManager.pImpl_->pipStateChangedListenerAgent_;
1010     auto oldListeners = windowManager.pImpl_->pipStateChangedListeners_;
1011     windowManager.pImpl_->pipStateChangedListenerAgent_ = nullptr;
1012     windowManager.pImpl_->pipStateChangedListeners_.clear();
1013     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterPiPStateChangedListener(nullptr));
1014 
1015     sptr<IPiPStateChangedListener> listener = new TestPiPStateChangedListener();
1016     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1017     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
1018     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.RegisterPiPStateChangedListener(listener));
1019     ASSERT_EQ(nullptr, windowManager.pImpl_->pipStateChangedListenerAgent_);
1020 
1021     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1022     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterPiPStateChangedListener(listener));
1023     ASSERT_EQ(1, windowManager.pImpl_->pipStateChangedListeners_.size());
1024 
1025     // to check that the same listner can not be registered twice
1026     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1027     ASSERT_EQ(WMError::WM_OK, windowManager.RegisterPiPStateChangedListener(listener));
1028     ASSERT_EQ(1, windowManager.pImpl_->pipStateChangedListeners_.size());
1029 
1030     windowManager.pImpl_->pipStateChangedListenerAgent_ = oldWindowManagerAgent;
1031     windowManager.pImpl_->pipStateChangedListeners_ = oldListeners;
1032 }
1033 
1034 /**
1035  * @tc.name: UnregisterPiPStateChangedListener
1036  * @tc.desc: check UnregisterPiPStateChangedListener
1037  * @tc.type: FUNC
1038  */
1039 HWTEST_F(WindowManagerLiteTest, UnregisterPiPStateChangedListener, Function | SmallTest | Level2)
1040 {
1041     auto& windowManager = WindowManagerLite::GetInstance();
1042     auto oldWindowManagerAgent = windowManager.pImpl_->pipStateChangedListenerAgent_;
1043     auto oldListeners = windowManager.pImpl_->pipStateChangedListeners_;
1044     windowManager.pImpl_->pipStateChangedListenerAgent_ = new (std::nothrow) WindowManagerAgentLite();
1045     windowManager.pImpl_->pipStateChangedListeners_.clear();
1046     // check nullpter
1047     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowManager.UnregisterPiPStateChangedListener(nullptr));
1048 
1049     sptr<IPiPStateChangedListener> listener1 = new TestPiPStateChangedListener();
1050     sptr<IPiPStateChangedListener> listener2 = new TestPiPStateChangedListener();
1051     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener1));
1052 
1053     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1054     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1055     windowManager.RegisterPiPStateChangedListener(listener1);
1056     EXPECT_CALL(m->Mock(), RegisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1057     windowManager.RegisterPiPStateChangedListener(listener2);
1058     ASSERT_EQ(2, windowManager.pImpl_->pipStateChangedListeners_.size());
1059 
1060     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener1));
1061     EXPECT_CALL(m->Mock(), UnregisterWindowManagerAgent(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1062     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener2));
1063     ASSERT_EQ(0, windowManager.pImpl_->pipStateChangedListeners_.size());
1064     ASSERT_EQ(nullptr, windowManager.pImpl_->pipStateChangedListenerAgent_);
1065 
1066     windowManager.pImpl_->pipStateChangedListeners_.push_back(listener1);
1067     ASSERT_EQ(WMError::WM_OK, windowManager.UnregisterPiPStateChangedListener(listener1));
1068     ASSERT_EQ(0, windowManager.pImpl_->pipStateChangedListeners_.size());
1069     windowManager.pImpl_->pipStateChangedListenerAgent_ = oldWindowManagerAgent;
1070     windowManager.pImpl_->pipStateChangedListeners_ = oldListeners;
1071 }
1072 
1073 /**
1074  * @tc.name: CloseTargetPiPWindow
1075  * @tc.desc: check CloseTargetPiPWindow
1076  * @tc.type: FUNC
1077  */
1078 HWTEST_F(WindowManagerLiteTest, CloseTargetPiPWindow, Function | SmallTest | Level2)
1079 {
1080     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1081     std::string bundleName = "test";
1082     EXPECT_CALL(m->Mock(), CloseTargetPiPWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1083 
1084     auto errorCode = WindowManagerLite::GetInstance().CloseTargetPiPWindow(bundleName);
1085     ASSERT_EQ(WMError::WM_OK, errorCode);
1086 }
1087 
1088 /**
1089  * @tc.name: GetCurrentPiPWindowInfo01
1090  * @tc.desc: check GetCurrentPiPWindowInfo
1091  * @tc.type: FUNC
1092  */
1093 HWTEST_F(WindowManagerLiteTest, GetCurrentPiPWindowInfo01, Function | SmallTest | Level2)
1094 {
1095     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1096     EXPECT_CALL(m->Mock(), GetCurrentPiPWindowInfo(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1097 
1098     std::string bundleName;
1099     auto errorCode = WindowManagerLite::GetInstance().GetCurrentPiPWindowInfo(bundleName);
1100     ASSERT_EQ(WMError::WM_OK, errorCode);
1101     ASSERT_EQ("", bundleName);
1102 }
1103 
1104 /**
1105  * @tc.name: GetCurrentPiPWindowInfo02
1106  * @tc.desc: check GetCurrentPiPWindowInfo
1107  * @tc.type: FUNC
1108  */
1109 HWTEST_F(WindowManagerLiteTest, GetCurrentPiPWindowInfo02, Function | SmallTest | Level2)
1110 {
1111     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1112     std::string testBundleName = "test";
1113     EXPECT_CALL(m->Mock(), GetCurrentPiPWindowInfo(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(testBundleName),
1114         Return(WMError::WM_OK)));
1115 
1116     std::string bundleName;
1117     auto errorCode = WindowManagerLite::GetInstance().GetCurrentPiPWindowInfo(bundleName);
1118     ASSERT_EQ(WMError::WM_OK, errorCode);
1119     ASSERT_EQ(testBundleName, bundleName);
1120 }
1121 }
1122 }