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