1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "event_handler.h"
18 #include "accessibility_account_data.h"
19 #include "accessibility_common_helper.h"
20 #include "accessibility_element_operator_proxy.h"
21 #include "accessibility_ut_helper.h"
22 #include "accessibility_window_manager.h"
23 #include "accessible_ability_manager_service.h"
24 #include "iservice_registry.h"
25 #include "mock_accessible_ability_manager_service.h"
26 #include "mock_accessibility_element_operator_proxy.h"
27 #include "mock_accessibility_element_operator_stub.h"
28 #include "mock_bundle_manager.h"
29 #include "mock_accessibility_setting_provider.h"
30
31 using namespace testing;
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace Accessibility {
36 namespace {
37 constexpr int RETRY_TIMES = 10;
38 constexpr int WINDOW_ID = 2;
39 constexpr int WINDOWS_SIZE = 2;
40 constexpr int SEND_EVENT_TIMES = 2;
41 constexpr int32_t ACCOUNT_ID = 100;
42 constexpr int32_t INNER_WINDOW_ID = 4;
43 constexpr int64_t INNER_ELEMENT_ID = 5;
44 constexpr int64_t INVALID_ELEMENT_ID = -1;
45 } // namespace
46
47 class AccessibilityWindowManagerTest : public testing::Test {
48 public:
AccessibilityWindowManagerTest()49 AccessibilityWindowManagerTest()
50 {}
~AccessibilityWindowManagerTest()51 ~AccessibilityWindowManagerTest()
52 {}
53
54 static void SetUpTestCase();
55 static void TearDownTestCase();
56 static void AddActiveWindow(AccessibilityWindowManager &windowInfoManager,
57 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst);
58 static void AddNormalWindow(AccessibilityWindowManager &windowInfoManager,
59 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond);
60 void SetUp() override;
61 void TearDown() override;
62 };
63
SetUpTestCase()64 void AccessibilityWindowManagerTest::SetUpTestCase()
65 {
66 GTEST_LOG_(INFO) << "AccessibilityWindowManagerTest SetUpTestCase";
67 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
68 }
69
TearDownTestCase()70 void AccessibilityWindowManagerTest::TearDownTestCase()
71 {
72 GTEST_LOG_(INFO) << "AccessibilityWindowManagerTest TearDownTestCase";
73 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
74 }
75
SetUp()76 void AccessibilityWindowManagerTest::SetUp()
77 {
78 GTEST_LOG_(INFO) << "AccessibilityWindowManagerTest SetUp";
79 AccessibilityAbilityHelper::GetInstance().ClearSendEventTimes();
80 }
81
TearDown()82 void AccessibilityWindowManagerTest::TearDown()
83 {
84 GTEST_LOG_(INFO) << "AccessibilityWindowManagerTest TearDown.";
85 }
86
GetRosenWindowInfo(Rosen::WindowType windowType)87 sptr<Rosen::AccessibilityWindowInfo> GetRosenWindowInfo(Rosen::WindowType windowType)
88 {
89 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
90 if (rosen_winInfo != nullptr) {
91 rosen_winInfo->type_ = windowType;
92 rosen_winInfo->wid_ = 1;
93 rosen_winInfo->windowRect_.width_ = 1;
94 rosen_winInfo->windowRect_.height_ = 1;
95 rosen_winInfo->windowRect_.posX_ = 1;
96 rosen_winInfo->windowRect_.posY_ = 1;
97 rosen_winInfo->focused_ = true;
98 rosen_winInfo->innerWid_ = 1;
99 }
100 return rosen_winInfo;
101 }
102
AddActiveWindow(AccessibilityWindowManager & windowInfoManager,sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst)103 void AccessibilityWindowManagerTest::AddActiveWindow(AccessibilityWindowManager &windowInfoManager,
104 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst)
105 {
106 rosenWinInfoFirst->type_ = Rosen::WindowType::WINDOW_TYPE_APP_MAIN_WINDOW;
107 rosenWinInfoFirst->wid_ = 1;
108 rosenWinInfoFirst->focused_ = false;
109 Rosen::Rect rect;
110 rect.posX_ = 1;
111 rect.posY_ = 1;
112 rect.width_ = 1;
113 rect.height_ = 1;
114 rosenWinInfoFirst->windowRect_ = rect;
115 rosenWinInfoFirst->mode_ = Rosen::WindowMode::WINDOW_MODE_PIP;
116 rosenWinInfoFirst->isDecorEnable_ = false;
117 rosenWinInfoFirst->displayId_ = 0;
118 rosenWinInfoFirst->innerWid_ = 1;
119 windowInfoManager.a11yWindows_.insert(std::make_pair(rosenWinInfoFirst->wid_,
120 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfoFirst)));
121 EXPECT_EQ(windowInfoManager.a11yWindows_.size(), 1);
122 }
123
AddNormalWindow(AccessibilityWindowManager & windowInfoManager,sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond)124 void AccessibilityWindowManagerTest::AddNormalWindow(AccessibilityWindowManager &windowInfoManager,
125 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond)
126 {
127 rosenWinInfoSecond->type_ = Rosen::WindowType::APP_WINDOW_BASE;
128 rosenWinInfoSecond->wid_ = WINDOW_ID;
129 rosenWinInfoSecond->focused_ = false;
130 Rosen::Rect rect;
131 rect.posX_ = 1;
132 rect.posY_ = 1;
133 rect.width_ = 1;
134 rect.height_ = 1;
135 rosenWinInfoSecond->windowRect_ = rect;
136 rosenWinInfoSecond->mode_ = Rosen::WindowMode::WINDOW_MODE_PIP;
137 rosenWinInfoSecond->isDecorEnable_ = false;
138 rosenWinInfoSecond->displayId_ = 0;
139 rosenWinInfoSecond->innerWid_ = WINDOW_ID;
140 windowInfoManager.a11yWindows_.insert(std::make_pair(rosenWinInfoSecond->wid_,
141 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfoSecond)));
142 EXPECT_EQ(windowInfoManager.a11yWindows_.size(), WINDOWS_SIZE);
143 }
144
145 /**
146 * @tc.number: AccessibilityWindowManager_Unittest_ConvertToRealWindowId001
147 * @tc.name: ConvertToRealWindowId
148 * @tc.desc: Test function ConvertToRealWindowId
149 */
150 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ConvertToRealWindowId001, TestSize.Level1)
151 {
152 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId001 start";
153 int32_t windowId = ACTIVE_WINDOW_ID;
154 int32_t focusType = 0;
155 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
156 int32_t realId = mgr.ConvertToRealWindowId(windowId, focusType);
157
158 EXPECT_EQ(mgr.activeWindowId_, realId);
159 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId001 end";
160 }
161
162 /**
163 * @tc.number: AccessibilityWindowManager_Unittest_ConvertToRealWindowId002
164 * @tc.name: ConvertToRealWindowId
165 * @tc.desc: Test function ConvertToRealWindowId
166 */
167 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ConvertToRealWindowId002, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId002 start";
170 int32_t windowId = ANY_WINDOW_ID;
171 int32_t focusType = FOCUS_TYPE_ACCESSIBILITY;
172 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
173 int32_t realId = mgr.ConvertToRealWindowId(windowId, focusType);
174
175 EXPECT_EQ(mgr.a11yFocusedWindowId_, realId);
176 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId002 end";
177 }
178
179 /**
180 * @tc.number: AccessibilityWindowManager_Unittest_ConvertToRealWindowId003
181 * @tc.name: ConvertToRealWindowId
182 * @tc.desc: Test function ConvertToRealWindowId
183 */
184 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ConvertToRealWindowId003, TestSize.Level1)
185 {
186 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId003 start";
187 int32_t windowId = ANY_WINDOW_ID;
188 int32_t focusType = FOCUS_TYPE_INPUT;
189 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
190 int32_t realId = mgr.ConvertToRealWindowId(windowId, focusType);
191
192 EXPECT_EQ(mgr.activeWindowId_, realId);
193 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId003 end";
194 }
195
196 /**
197 * @tc.number: AccessibilityWindowManager_Unittest_ConvertToRealWindowId004
198 * @tc.name: ConvertToRealWindowId
199 * @tc.desc: Test function ConvertToRealWindowId
200 */
201 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ConvertToRealWindowId004, TestSize.Level1)
202 {
203 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId004 start";
204 int32_t windowId = INVALID_WINDOW_ID;
205 int32_t focusType = FOCUS_TYPE_INPUT;
206 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
207 int32_t realId = mgr.ConvertToRealWindowId(windowId, focusType);
208
209 EXPECT_EQ(windowId, realId);
210 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ConvertToRealWindowId004 end";
211 }
212
213 /**
214 * @tc.number: AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo001
215 * @tc.name: CreateAccessibilityWindowInfo
216 * @tc.desc: Test function CreateAccessibilityWindowInfo
217 */
218 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo001,
219 TestSize.Level1)
220 {
221 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo001 start";
222 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_MAIN_WINDOW_BASE);
223 EXPECT_TRUE(rosen_winInfo != nullptr);
224
225 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
226 infos.emplace_back(rosen_winInfo);
227
228 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
229 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
230
231 EXPECT_EQ(TYPE_APPLICATION, info.GetAccessibilityWindowType());
232 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo001 end";
233 }
234
235 /**
236 * @tc.number: AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo002
237 * @tc.name: CreateAccessibilityWindowInfo
238 * @tc.desc: Test function CreateAccessibilityWindowInfo
239 */
240 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo002,
241 TestSize.Level1)
242 {
243 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo002 start";
244 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
245 Rosen::WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
246 EXPECT_TRUE(rosen_winInfo != nullptr);
247
248 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
249 infos.emplace_back(rosen_winInfo);
250
251 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
252 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
253
254 EXPECT_EQ(TYPE_SYSTEM, info.GetAccessibilityWindowType());
255 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo002 end";
256 }
257
258 /**
259 * @tc.number: AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo003
260 * @tc.name: CreateAccessibilityWindowInfo
261 * @tc.desc: Test function CreateAccessibilityWindowInfo
262 */
263 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo003,
264 TestSize.Level1)
265 {
266 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo003 start";
267
268 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
269 static_cast<OHOS::Rosen::WindowType>(0xFFFFFFFF));
270 EXPECT_TRUE(rosen_winInfo != nullptr);
271
272 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
273 infos.emplace_back(rosen_winInfo);
274
275 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
276 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
277
278 EXPECT_EQ(TYPE_WINDOW_INVALID, info.GetAccessibilityWindowType());
279 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo003 end";
280 }
281
282 /**
283 * @tc.number: AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo004
284 * @tc.name: CreateAccessibilityWindowInfo
285 * @tc.desc: Test function CreateAccessibilityWindowInfo
286 */
287 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo004,
288 TestSize.Level1)
289 {
290 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo004 start";
291
292 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
293 Rosen::WindowType::WINDOW_TYPE_UI_EXTENSION);
294 EXPECT_TRUE(rosen_winInfo != nullptr);
295
296 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
297 infos.emplace_back(rosen_winInfo);
298
299 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
300 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
301
302 EXPECT_EQ(TYPE_WINDOW_INVALID, info.GetAccessibilityWindowType());
303 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo004 end";
304 }
305
306 /**
307 * @tc.number: AccessibilityWindowManager_Unittest_GetActiveWindowId_001
308 * @tc.name: GetActiveWindowId
309 * @tc.desc: Test function GetActiveWindowId
310 */
311 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetActiveWindowId001,
312 TestSize.Level1)
313 {
314 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetActiveWindowId_001 start";
315
316 Singleton<AccessibilityWindowManager>::GetInstance().GetActiveWindowId();
317
318 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetActiveWindowId_001 end";
319 }
320
321 /**
322 * @tc.number: AccessibilityWindowManager_Unittest_RegisterWindowListener001
323 * @tc.name: RegisterWindowListener
324 * @tc.desc: Test function RegisterWindowListener
325 */
326 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_RegisterWindowListener001,
327 TestSize.Level1)
328 {
329 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_RegisterWindowListener001 start";
330
331 Singleton<AccessibilityWindowManager>::GetInstance().RegisterWindowListener(nullptr);
332
333 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_RegisterWindowListener001 end";
334 }
335
336 /**
337 * @tc.number: AccessibilityWindowManager_Unittest_RegisterWindowListener002
338 * @tc.name: RegisterWindowListener
339 * @tc.desc: Test function RegisterWindowListener
340 */
341 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_RegisterWindowListener002,
342 TestSize.Level1)
343 {
344 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_RegisterWindowListener002 start";
345
346 const std::string AAMS_SERVICE_NAME = "AccessibleAbilityManagerService";
347 std::shared_ptr<AppExecFwk::EventRunner> runner_ =
348 AppExecFwk::EventRunner::Create(AAMS_SERVICE_NAME, AppExecFwk::ThreadMode::FFRT);
349 std::shared_ptr<AppExecFwk::EventHandler> handler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
350
351 Singleton<AccessibilityWindowManager>::GetInstance().RegisterWindowListener(handler_);
352 EXPECT_NE(handler_, nullptr);
353
354 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_RegisterWindowListener002 end";
355 }
356
357 /**
358 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange001
359 * @tc.name: OnWindowChange
360 * @tc.desc: Test function OnWindowChange
361 */
362 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange001, TestSize.Level1)
363 {
364 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange001 start";
365 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
366 EXPECT_TRUE(rosen_winInfo != nullptr);
367 rosen_winInfo->focused_ = false;
368
369 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
370 infos.emplace_back(rosen_winInfo);
371
372 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
373 windowInfoManager.a11yWindows_.clear();
374 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
375
376 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED);
377 int retryCount = 0;
378 while (retryCount < RETRY_TIMES) {
379 sleep(1);
380 int counts = AccessibilityAbilityHelper::GetInstance().GetSendEventTimes();
381 GTEST_LOG_(INFO) << "The counts of send event is : " << counts;
382 if (counts == 1) {
383 GTEST_LOG_(INFO) << "update window successful";
384 break;
385 }
386 retryCount++;
387 }
388 EXPECT_TRUE(windowInfoManager.a11yWindows_.size() == 1);
389 EXPECT_TRUE(windowInfoManager.a11yWindows_.count(rosen_winInfo->wid_));
390 windowInfoManager.a11yWindows_.clear();
391 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange001 end";
392 }
393
394 /**
395 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange002
396 * @tc.name: OnWindowChange
397 * @tc.desc: Test function OnWindowchange
398 */
399 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange002, TestSize.Level1)
400 {
401 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange002 start";
402 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();;
403 EXPECT_TRUE(rosen_winInfo != nullptr);
404 rosen_winInfo->type_ = Rosen::WindowType::APP_WINDOW_BASE;
405 rosen_winInfo->wid_ = 1;
406 rosen_winInfo->focused_ = true;
407 rosen_winInfo->innerWid_ = 1;
408
409 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
410 infos.emplace_back(rosen_winInfo);
411
412 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
413 windowInfoManager.a11yWindows_.clear();
414 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
415 EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
416
417 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE);
418 int retryCount = 0;
419 while (retryCount < RETRY_TIMES) {
420 sleep(1);
421 int counts = AccessibilityAbilityHelper::GetInstance().GetSendEventTimes();
422 GTEST_LOG_(INFO) << "The counts of send event is : " << counts;
423 if (counts == 1) {
424 GTEST_LOG_(INFO) << "update window successful";
425 break;
426 }
427 retryCount++;
428 }
429 EXPECT_TRUE(windowInfoManager.a11yWindows_.size() == 1);
430 EXPECT_TRUE(windowInfoManager.a11yWindows_.count(rosen_winInfo->wid_));
431 EXPECT_EQ(windowInfoManager.activeWindowId_, rosen_winInfo->wid_);
432 windowInfoManager.a11yWindows_.clear();
433 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange002 end";
434 }
435
436 /**
437 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange003
438 * @tc.name: OnWindowChange
439 * @tc.desc: Test function OnWindowChange
440 */
441 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange003, TestSize.Level1)
442 {
443 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange003 start";
444 // Clear window data
445 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
446 windowInfoManager.a11yWindows_.clear();
447 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
448
449 // Add a window
450 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst = new Rosen::AccessibilityWindowInfo();
451 AddActiveWindow(windowInfoManager, rosenWinInfoFirst);
452
453 // Add another window
454 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond = new Rosen::AccessibilityWindowInfo();
455 AddNormalWindow(windowInfoManager, rosenWinInfoSecond);
456
457 // Remove the first window
458 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
459 infos.emplace_back(rosenWinInfoFirst);
460 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
461
462 int retryCount = 0;
463 while (retryCount < RETRY_TIMES) {
464 sleep(1);
465 int counts = AccessibilityAbilityHelper::GetInstance().GetSendEventTimes();
466 GTEST_LOG_(INFO) << "The counts of send event is : " << counts;
467 if (counts == 1) {
468 GTEST_LOG_(INFO) << "update window successful";
469 break;
470 }
471 retryCount++;
472 }
473 EXPECT_TRUE(windowInfoManager.a11yWindows_.size() == 1);
474 EXPECT_FALSE(windowInfoManager.a11yWindows_.count(rosenWinInfoFirst->wid_));
475 EXPECT_TRUE(windowInfoManager.a11yWindows_.count(rosenWinInfoSecond->wid_));
476 windowInfoManager.a11yWindows_.clear();
477 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange003 end";
478 }
479
480 /**
481 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange004
482 * @tc.name: OnWindowChange
483 * @tc.desc: Test function OnWindowChange
484 */
485 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange004, TestSize.Level1)
486 {
487 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange004 start";
488 // Clear window data
489 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
490 windowInfoManager.a11yWindows_.clear();
491 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
492 EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
493
494 // Add an active window
495 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst = new Rosen::AccessibilityWindowInfo();
496 AddActiveWindow(windowInfoManager, rosenWinInfoFirst);
497 windowInfoManager.SetActiveWindow(rosenWinInfoFirst->wid_);
498 EXPECT_EQ(windowInfoManager.activeWindowId_, rosenWinInfoFirst->wid_);
499
500 // Add another normal window
501 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond = new Rosen::AccessibilityWindowInfo();
502 AddNormalWindow(windowInfoManager, rosenWinInfoSecond);
503
504 // Remove the active window
505 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
506 infos.emplace_back(rosenWinInfoFirst);
507 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
508
509 int retryCount = 0;
510 while (retryCount < RETRY_TIMES) {
511 sleep(1);
512 int counts = AccessibilityAbilityHelper::GetInstance().GetSendEventTimes();
513 GTEST_LOG_(INFO) << "The counts of send event is : " << counts;
514 if (counts == SEND_EVENT_TIMES) {
515 GTEST_LOG_(INFO) << "update window successful";
516 break;
517 }
518 retryCount++;
519 }
520 EXPECT_TRUE(windowInfoManager.a11yWindows_.size() == 1);
521 EXPECT_FALSE(windowInfoManager.a11yWindows_.count(rosenWinInfoFirst->wid_));
522 EXPECT_TRUE(windowInfoManager.a11yWindows_.count(rosenWinInfoSecond->wid_));
523 EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
524 windowInfoManager.a11yWindows_.clear();
525 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange004 end";
526 }
527
528 /**
529 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange005
530 * @tc.name: OnWindowChange
531 * @tc.desc: Test function OnWindowChange(WindowUpdateBounds fail)
532 */
533 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange005, TestSize.Level1)
534 {
535 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange005 start";
536
537 AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED);
538 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
539 infos.emplace_back(nullptr);
540 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
541 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_BOUNDS);
542 sleep(1);
543 EXPECT_EQ(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED,
544 AccessibilityAbilityHelper::GetInstance().GetEventWindowChangeType());
545 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange005 end";
546 }
547
548 /**
549 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange006
550 * @tc.name: OnWindowChange
551 * @tc.desc: Test function OnWindowChange(WindowUpdateBounds success)
552 */
553 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange006, TestSize.Level1)
554 {
555 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange006 start";
556
557 AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED);
558 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
559 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
560 infos.emplace_back(winInfo);
561 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
562 windowInfoManager.a11yWindows_.clear();
563 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_BOUNDS);
564 ASSERT_TRUE(windowInfoManager.a11yWindows_.size() == 0);
565 windowInfoManager.a11yWindows_.clear();
566 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange006 end";
567 }
568
569 /**
570 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange007
571 * @tc.name: OnWindowChange
572 * @tc.desc: Test function OnWindowChange(WindowUpdateFocused fail)
573 */
574 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange007, TestSize.Level1)
575 {
576 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange007 start";
577
578 AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED);
579 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
580 infos.emplace_back(nullptr);
581 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
582 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_FOCUSED);
583 EXPECT_EQ(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED,
584 AccessibilityAbilityHelper::GetInstance().GetEventWindowChangeType());
585 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange007 end";
586 }
587
588 /**
589 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange008
590 * @tc.name: OnWindowChange
591 * @tc.desc: Test function OnWindowChange(WindowUpdateFocused success(a11yWindows_ is not null))
592 */
593 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange008, TestSize.Level1)
594 {
595 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange008 start";
596
597 AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED);
598 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
599 // Add a window
600 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
601 rosenWinInfo->wid_ = 1;
602 windowInfoManager.a11yWindows_.insert(std::make_pair(1,
603 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
604 EXPECT_EQ(windowInfoManager.a11yWindows_.size(), 1);
605
606 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
607 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
608 winInfo->wid_ = 1;
609 infos.emplace_back(winInfo);
610 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_FOCUSED);
611 windowInfoManager.a11yWindows_.clear();
612 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange008 end";
613 }
614
615 /**
616 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange009
617 * @tc.name: OnWindowChange
618 * @tc.desc: Test function OnWindowChange(WindowUpdateFocused success(a11yWindows_ is null))
619 */
620 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange009, TestSize.Level1)
621 {
622 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange009 start";
623
624 AccessibilityAbilityHelper::GetInstance().SetEventWindowChangeType(WINDOW_UPDATE_ACCESSIBILITY_FOCUSED);
625 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
626 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
627 winInfo->wid_ = 1;
628 infos.emplace_back(winInfo);
629 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
630 windowInfoManager.a11yWindows_.clear();
631 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_FOCUSED);
632 ASSERT_TRUE(windowInfoManager.a11yWindows_.size() == 0);
633 windowInfoManager.a11yWindows_.clear();
634 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange009 end";
635 }
636
637 /**
638 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange010
639 * @tc.name: OnWindowChange
640 * @tc.desc: Test function OnWindowChange(WindowUpdateProperty fail)
641 */
642 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange010, TestSize.Level1)
643 {
644 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange010 start";
645
646 // Add window
647 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
648 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
649 rosenWinInfo->wid_ = WINDOW_ID;
650 rosenWinInfo->focused_ = false;
651 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
652 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
653
654 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
655 infos.emplace_back(nullptr);
656 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_PROPERTY);
657 sleep(1);
658 EXPECT_TRUE(!windowInfoManager.a11yWindows_[WINDOW_ID].IsFocused());
659 windowInfoManager.a11yWindows_.clear();
660 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange010 end";
661 }
662
663 /**
664 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange011
665 * @tc.name: OnWindowChange
666 * @tc.desc: Test function OnWindowChange(WindowUpdateProperty fail)
667 */
668 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange011, TestSize.Level1)
669 {
670 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange011 start";
671
672 // Add window
673 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
674 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
675 rosenWinInfo->wid_ = WINDOW_ID;
676 rosenWinInfo->focused_ = false;
677 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
678 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
679 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
680
681 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
682 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
683 winInfo->wid_ = 1;
684 winInfo->focused_ = true;
685 infos.emplace_back(winInfo);
686 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_PROPERTY);
687 sleep(1);
688 EXPECT_TRUE(!windowInfoManager.a11yWindows_[WINDOW_ID].IsFocused());
689 windowInfoManager.a11yWindows_.clear();
690 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange011 end";
691 }
692
693 /**
694 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange012
695 * @tc.name: OnWindowChange
696 * @tc.desc: Test function OnWindowChange(WindowUpdateProperty success)
697 */
698 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange012, TestSize.Level1)
699 {
700 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange012 start";
701
702 // Add window
703 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
704 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
705 rosenWinInfo->wid_ = WINDOW_ID;
706 rosenWinInfo->focused_ = false;
707 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
708 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
709 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
710
711 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
712 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
713 winInfo->wid_ = WINDOW_ID;
714 winInfo->focused_ = true;
715 infos.emplace_back(winInfo);
716 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_PROPERTY);
717 sleep(1);
718 windowInfoManager.a11yWindows_.clear();
719 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange012 end";
720 }
721
722 /**
723 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange013
724 * @tc.name: OnWindowChange
725 * @tc.desc: Test function OnWindowChange(size of parameter(infos) is 0)
726 */
727 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange013, TestSize.Level1)
728 {
729 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange013 start";
730
731 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
732 windowInfoManager.a11yWindows_.clear();
733 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
734 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED);
735 EXPECT_EQ(0, windowInfoManager.a11yWindows_.size());
736 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange013 end";
737 }
738
739 /**
740 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange014
741 * @tc.name: OnWindowChange
742 * @tc.desc: Test function OnWindowChange(WindowUpdateAdded fail)
743 */
744 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange014, TestSize.Level1)
745 {
746 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange014 start";
747
748 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
749 windowInfoManager.a11yWindows_.clear();
750 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
751 infos.emplace_back(nullptr);
752 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED);
753 sleep(1);
754 EXPECT_EQ(0, windowInfoManager.a11yWindows_.size());
755 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange014 end";
756 }
757
758 /**
759 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange015
760 * @tc.name: OnWindowChange
761 * @tc.desc: Test function OnWindowChange(WindowUpdateAdded success)
762 */
763 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange015, TestSize.Level1)
764 {
765 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange015 start";
766
767 // Add window
768 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
769 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo1 = new Rosen::AccessibilityWindowInfo();
770 rosenWinInfo1->wid_ = WINDOW_ID;
771 rosenWinInfo1->focused_ = false;
772 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
773 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo1)));
774
775 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo2 = new Rosen::AccessibilityWindowInfo();
776 rosenWinInfo2->wid_ = 1;
777 rosenWinInfo2->focused_ = false;
778 windowInfoManager.a11yWindows_.insert(std::make_pair(1,
779 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo2)));
780 windowInfoManager.activeWindowId_ = 1;
781
782 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
783 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
784 winInfo->wid_ = WINDOW_ID;
785 winInfo->focused_ = true;
786 infos.emplace_back(winInfo);
787 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED);
788 sleep(1);
789 windowInfoManager.a11yWindows_.clear();
790 EXPECT_EQ(windowInfoManager.a11yWindows_.size(), 0);
791 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange015 end";
792 }
793
794 /**
795 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange016
796 * @tc.name: OnWindowChange
797 * @tc.desc: Test function OnWindowChange(WindowUpdateRemoved fail)
798 */
799 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange016, TestSize.Level1)
800 {
801 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange016 start";
802
803 // Add window
804 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
805 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
806 rosenWinInfo->wid_ = WINDOW_ID;
807 rosenWinInfo->focused_ = false;
808 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
809 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
810 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
811
812 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
813 infos.emplace_back(nullptr);
814 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
815 sleep(1);
816 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
817 windowInfoManager.a11yWindows_.clear();
818 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange016 end";
819 }
820
821 /**
822 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange017
823 * @tc.name: OnWindowChange
824 * @tc.desc: Test function OnWindowChange(WindowUpdateRemoved success)
825 */
826 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange017, TestSize.Level1)
827 {
828 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange017 start";
829
830 // Add window
831 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
832 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
833 rosenWinInfo->wid_ = WINDOW_ID;
834 rosenWinInfo->focused_ = false;
835 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
836 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
837 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
838 windowInfoManager.a11yFocusedWindowId_ = WINDOW_ID;
839
840 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
841 sptr<Rosen::AccessibilityWindowInfo> winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
842 winInfo->wid_ = WINDOW_ID;
843 winInfo->focused_ = true;
844 infos.emplace_back(winInfo);
845 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
846 sleep(1);
847 EXPECT_EQ(0, windowInfoManager.a11yWindows_.size());
848 windowInfoManager.a11yWindows_.clear();
849 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange017 end";
850 }
851
852 /**
853 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange018
854 * @tc.name: OnWindowChange
855 * @tc.desc: Test function OnWindowChange(WindowUpdateActive fail)
856 */
857 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange018, TestSize.Level1)
858 {
859 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange018 start";
860
861 // Add window
862 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
863 sptr<Rosen::AccessibilityWindowInfo> rosenWinInfo = new Rosen::AccessibilityWindowInfo();
864 rosenWinInfo->wid_ = WINDOW_ID;
865 rosenWinInfo->focused_ = false;
866 windowInfoManager.a11yWindows_.insert(std::make_pair(WINDOW_ID,
867 windowInfoManager.CreateAccessibilityWindowInfo(rosenWinInfo)));
868 EXPECT_EQ(1, windowInfoManager.a11yWindows_.size());
869 windowInfoManager.activeWindowId_ = WINDOW_ID;
870
871 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
872 infos.emplace_back(nullptr);
873 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE);
874 sleep(1);
875 EXPECT_EQ(WINDOW_ID, windowInfoManager.activeWindowId_);
876 windowInfoManager.a11yWindows_.clear();
877 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange018 end";
878 }
879
880 /**
881 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange019
882 * @tc.name: OnWindowChange
883 * @tc.desc: Test function OnWindowChange(WindowUpdateAll success)
884 */
885 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange019, TestSize.Level1)
886 {
887 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange019 start";
888 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo_first = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
889 rosen_winInfo_first->bundleName_ = "rosen_winInfo_first";
890 rosen_winInfo_first->touchHotAreas_ = {Rosen::Rect{0, 0, 2, 2}, Rosen::Rect{2, 2, 4, 4}};
891
892 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo_second = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
893 rosen_winInfo_second->bundleName_ = "rosen_winInfo_second";
894 rosen_winInfo_second->touchHotAreas_ = {Rosen::Rect{0, 0, 3, 3}, Rosen::Rect{3, 3, 6, 6}};
895 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
896 infos.emplace_back(rosen_winInfo_first);
897 infos.emplace_back(rosen_winInfo_second);
898
899 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
900 windowInfoManager.a11yWindows_.clear();
901 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ALL);
902 for (auto& info : windowInfoManager.a11yWindows_) {
903 bool cmpFirstBundleName = info.second.GetBundleName() == "rosen_winInfo_first";
904 bool cmpSecondBundleName = info.second.GetBundleName() == "rosen_winInfo_second";
905 EXPECT_TRUE(cmpFirstBundleName || cmpSecondBundleName);
906 }
907 windowInfoManager.a11yWindows_.clear();
908 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange019 end";
909 }
910
911 /**
912 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowChange020
913 * @tc.name: OnWindowChange
914 * @tc.desc: Test function OnWindowChange(layer success)
915 */
916 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange020, TestSize.Level1)
917 {
918 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange020 start";
919 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo_first = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
920 rosen_winInfo_first->bundleName_ = "rosen_winInfo_first";
921 rosen_winInfo_first->touchHotAreas_ = {Rosen::Rect{0, 0, 2, 2}, Rosen::Rect{2, 2, 4, 4}};
922 rosen_winInfo_first->wid_ = 1;
923 rosen_winInfo_first->layer_ = 2;
924
925 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo_second = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
926 rosen_winInfo_second->bundleName_ = "rosen_winInfo_second";
927 rosen_winInfo_second->touchHotAreas_ = {Rosen::Rect{0, 0, 3, 3}, Rosen::Rect{3, 3, 6, 6}};
928 rosen_winInfo_second->wid_ = 2;
929 rosen_winInfo_second->innerWid_ = 2;
930 rosen_winInfo_second->layer_ = 1;
931 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
932 infos.emplace_back(rosen_winInfo_first);
933 infos.emplace_back(rosen_winInfo_second);
934
935 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
936 windowInfoManager.a11yWindows_.clear();
937 EXPECT_TRUE(windowInfoManager.a11yWindows_.size() == 0);
938 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ALL);
939 windowInfoManager.a11yWindows_.clear();
940 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange020 end";
941 }
942
943 /**
944 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow001
945 * @tc.name: SetActiveWindow
946 * @tc.desc: Test function SetActiveWindow
947 */
948 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow001, TestSize.Level1)
949 {
950 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow001 start";
951 /* map insert value */
952 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
953 AccessibilityWindowInfo info;
954 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
955 mgr.a11yWindows_.clear();
956 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
957 /* SetActiveWindow */
958 int32_t windowId = INVALID_WINDOW_ID;
959 mgr.SetActiveWindow(windowId);
960 /* test */
961 bool test1 = false;
962 if (mgr.a11yWindows_.count(ACTIVE_WINDOW_ID)) {
963 test1 = true;
964 }
965 EXPECT_FALSE(test1);
966 EXPECT_EQ(INVALID_WINDOW_ID, mgr.activeWindowId_);
967
968 mgr.a11yWindows_.clear();
969 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow001 end";
970 }
971
972 /**
973 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow002
974 * @tc.name: SetActiveWindow
975 * @tc.desc: Test function SetActiveWindow
976 */
977 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow002, TestSize.Level1)
978 {
979 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow002 start";
980 /* map insert value */
981 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
982 AccessibilityWindowInfo info;
983 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
984 mgr.a11yWindows_.clear();
985 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info));
986 /* SetActiveWindow */
987 int32_t windowId = INVALID_WINDOW_ID;
988 mgr.SetActiveWindow(windowId);
989 /* test */
990 bool test1 = false;
991 if (mgr.a11yWindows_.count(ACTIVE_WINDOW_ID)) {
992 test1 = true;
993 }
994 EXPECT_TRUE(test1);
995 bool test2 = mgr.a11yWindows_[ACTIVE_WINDOW_ID].IsActive();
996 EXPECT_FALSE(test2);
997 EXPECT_EQ(INVALID_WINDOW_ID, mgr.activeWindowId_);
998
999 mgr.a11yWindows_.clear();
1000 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow002 end";
1001 }
1002
1003 /**
1004 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow003
1005 * @tc.name: SetActiveWindow
1006 * @tc.desc: Test function SetActiveWindow
1007 */
1008 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow003, TestSize.Level1)
1009 {
1010 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow003 start";
1011 /* map insert value */
1012 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1013 AccessibilityWindowInfo info;
1014 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
1015 mgr.a11yWindows_.clear();
1016 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1017 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
1018 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1019 /* SetActiveWindow */
1020 int32_t windowId = ACTIVE_WINDOW_ID;
1021 mgr.SetActiveWindow(windowId);
1022 /* test */
1023 bool test1 = false;
1024 if (mgr.a11yWindows_.count(windowId)) {
1025 test1 = true;
1026 }
1027 EXPECT_FALSE(test1);
1028 EXPECT_EQ(ACTIVE_WINDOW_ID, mgr.activeWindowId_);
1029
1030 mgr.a11yWindows_.clear();
1031 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow003 end";
1032 }
1033
1034 /**
1035 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow004
1036 * @tc.name: SetActiveWindow
1037 * @tc.desc: Test function SetActiveWindow
1038 */
1039 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow004, TestSize.Level1)
1040 {
1041 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow004 start";
1042 /* map insert value */
1043 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1044 AccessibilityWindowInfo info1;
1045 AccessibilityWindowInfo info2;
1046 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
1047 int32_t windowId = ANY_WINDOW_ID;
1048 mgr.a11yWindows_.clear();
1049 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1050 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1051 mgr.a11yWindows_.insert(std::make_pair(windowId, info2));
1052 EXPECT_EQ(2, (int)mgr.a11yWindows_.size());
1053 /* SetActiveWindow */
1054 mgr.SetActiveWindow(windowId);
1055 /* test */
1056 bool test1 = false;
1057 if (mgr.a11yWindows_.count(ACTIVE_WINDOW_ID)) {
1058 test1 = true;
1059 }
1060 EXPECT_TRUE(test1);
1061 bool test2 = mgr.a11yWindows_[ACTIVE_WINDOW_ID].IsActive();
1062 EXPECT_FALSE(test2);
1063 EXPECT_EQ(ANY_WINDOW_ID, mgr.activeWindowId_);
1064 bool test3 = mgr.a11yWindows_[mgr.activeWindowId_].IsActive();
1065 EXPECT_TRUE(test3);
1066
1067 mgr.a11yWindows_.clear();
1068 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow004 end";
1069 }
1070
1071 /**
1072 * @tc.number: AccessibilityWindowManager_Unittest_SetActiveWindow005
1073 * @tc.name: SetActiveWindow
1074 * @tc.desc: Test function SetActiveWindow
1075 */
1076 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetActiveWindow005, TestSize.Level1)
1077 {
1078 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow005 start";
1079 /* map insert value */
1080 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1081 AccessibilityWindowInfo info1;
1082 AccessibilityWindowInfo info2;
1083 mgr.activeWindowId_ = ACTIVE_WINDOW_ID;
1084 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1085 int32_t windowId = ANY_WINDOW_ID;
1086 mgr.a11yWindows_.clear();
1087 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1088 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1089 mgr.a11yWindows_.insert(std::make_pair(windowId, info2));
1090 EXPECT_EQ(2, (int)mgr.a11yWindows_.size());
1091 /* SetActiveWindow */
1092 mgr.SetActiveWindow(windowId);
1093 /* test */
1094 EXPECT_EQ(INVALID_WINDOW_ID, mgr.a11yFocusedWindowId_);
1095 mgr.a11yWindows_.clear();
1096 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetActiveWindow005 end";
1097 }
1098
1099 /**
1100 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001
1101 * @tc.name: SetAccessibilityFocusedWindow
1102 * @tc.desc: Test function SetAccessibilityFocusedWindow
1103 */
1104 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001,
1105 TestSize.Level1)
1106 {
1107 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001 start";
1108 /* map insert value */
1109 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1110 AccessibilityWindowInfo info;
1111 mgr.a11yFocusedWindowId_ = ANY_WINDOW_ID;
1112 mgr.a11yWindows_.clear();
1113 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1114 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info));
1115 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1116 /* SetAccessibilityFocusedWindow */
1117 int32_t windowId = INVALID_WINDOW_ID;
1118 mgr.SetAccessibilityFocusedWindow(windowId);
1119 /* test */
1120 bool test1 = false;
1121 if (mgr.a11yWindows_.count(ANY_WINDOW_ID)) {
1122 test1 = true;
1123 }
1124 EXPECT_FALSE(test1);
1125 EXPECT_EQ(INVALID_WINDOW_ID, mgr.a11yFocusedWindowId_);
1126
1127 mgr.a11yWindows_.clear();
1128 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow001 end";
1129 }
1130
1131 /**
1132 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002
1133 * @tc.name: SetAccessibilityFocusedWindow
1134 * @tc.desc: Test function SetAccessibilityFocusedWindow
1135 */
1136 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002,
1137 TestSize.Level1)
1138 {
1139 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002 start";
1140 /* map insert value */
1141 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1142 AccessibilityWindowInfo info;
1143 mgr.a11yFocusedWindowId_ = ANY_WINDOW_ID;
1144 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1145 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
1146 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1147 /* SetAccessibilityFocusedWindow */
1148 int32_t windowId = INVALID_WINDOW_ID;
1149 mgr.SetAccessibilityFocusedWindow(windowId);
1150 /* test */
1151 bool test1 = false;
1152 if (mgr.a11yWindows_.count(ANY_WINDOW_ID)) {
1153 test1 = true;
1154 }
1155 EXPECT_TRUE(test1);
1156 bool test2 = mgr.a11yWindows_[ANY_WINDOW_ID].IsAccessibilityFocused();
1157 EXPECT_FALSE(test2);
1158 EXPECT_EQ(INVALID_WINDOW_ID, mgr.a11yFocusedWindowId_);
1159
1160 mgr.a11yWindows_.clear();
1161 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow002 end";
1162 }
1163
1164 /**
1165 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003
1166 * @tc.name: SetAccessibilityFocusedWindow
1167 * @tc.desc: Test function SetAccessibilityFocusedWindow
1168 */
1169 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003,
1170 TestSize.Level1)
1171 {
1172 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003 start";
1173 /* map insert value */
1174 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1175 AccessibilityWindowInfo info;
1176 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1177 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1178 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info));
1179 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1180 /* SetAccessibilityFocusedWindow */
1181 int32_t windowId = ACTIVE_WINDOW_ID;
1182 mgr.SetAccessibilityFocusedWindow(windowId);
1183 /* test */
1184 bool test1 = false;
1185 if (mgr.a11yWindows_.count(windowId)) {
1186 test1 = true;
1187 }
1188 EXPECT_FALSE(test1);
1189 EXPECT_EQ(ACTIVE_WINDOW_ID, mgr.a11yFocusedWindowId_);
1190
1191 mgr.a11yWindows_.clear();
1192 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow003 end";
1193 }
1194
1195 /**
1196 * @tc.number: AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004
1197 * @tc.name: SetAccessibilityFocusedWindow
1198 * @tc.desc: Test function SetAccessibilityFocusedWindow
1199 */
1200 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004,
1201 TestSize.Level1)
1202 {
1203 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004 start";
1204 /* map insert value */
1205 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1206 AccessibilityWindowInfo info1;
1207 AccessibilityWindowInfo info2;
1208 mgr.a11yFocusedWindowId_ = ANY_WINDOW_ID;
1209 int32_t windowId = ACTIVE_WINDOW_ID;
1210 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1211 mgr.a11yWindows_.insert(std::make_pair(ANY_WINDOW_ID, info1));
1212 mgr.a11yWindows_.insert(std::make_pair(windowId, info2));
1213 EXPECT_EQ(2, (int)mgr.a11yWindows_.size());
1214 /* SetAccessibilityFocusedWindow */
1215 mgr.SetAccessibilityFocusedWindow(windowId);
1216 /* test */
1217 bool test1 = false;
1218 if (mgr.a11yWindows_.count(ANY_WINDOW_ID)) {
1219 test1 = true;
1220 }
1221 EXPECT_TRUE(test1);
1222 bool test2 = mgr.a11yWindows_[ANY_WINDOW_ID].IsAccessibilityFocused();
1223 EXPECT_FALSE(test2);
1224 EXPECT_EQ(ACTIVE_WINDOW_ID, mgr.a11yFocusedWindowId_);
1225 bool test3 = mgr.a11yWindows_[mgr.a11yFocusedWindowId_].IsAccessibilityFocused();
1226 EXPECT_TRUE(test3);
1227
1228 mgr.a11yWindows_.clear();
1229 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetAccessibilityFocusedWindow004 end";
1230 }
1231
1232 /**
1233 * @tc.number: AccessibilityWindowManager_Unittest_GetAccessibilityWindows001
1234 * @tc.name: GetAccessibilityWindows
1235 * @tc.desc: Test function GetAccessibilityWindows
1236 */
1237 HWTEST_F(
1238 AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetAccessibilityWindows001, TestSize.Level1)
1239 {
1240 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindows001 start";
1241 /* map insert value */
1242 int32_t windowId = ANY_WINDOW_ID;
1243
1244 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1245 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1246 EXPECT_TRUE(rosen_winInfo != nullptr);
1247
1248 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1249 infos.emplace_back(rosen_winInfo);
1250
1251 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1252 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1253 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1254 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1255 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1256 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1257
1258 /* SetAccessibilityFocusedWindow */
1259 mgr.SetAccessibilityFocusedWindow(windowId);
1260
1261 /* GetAccessibilityWindows */
1262 std::vector<AccessibilityWindowInfo> windows = mgr.GetAccessibilityWindows();
1263 ASSERT_EQ(1, (int)windows.size());
1264 static Accessibility::AccessibilityWindowType type = windows.begin()->GetAccessibilityWindowType();
1265 EXPECT_EQ(AccessibilityWindowType::TYPE_APPLICATION, type);
1266
1267 mgr.a11yWindows_.clear();
1268 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindows001 end";
1269 }
1270
1271 /**
1272 * @tc.number: AccessibilityWindowManager_Unittest_GetAccessibilityWindow001
1273 * @tc.name: GetAccessibilityWindow
1274 * @tc.desc: Test function GetAccessibilityWindow
1275 */
1276 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetAccessibilityWindow001, TestSize.Level1)
1277 {
1278 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow001 start";
1279 /* map insert value */
1280 int32_t windowId = ANY_WINDOW_ID;
1281
1282 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1283 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1284 EXPECT_TRUE(rosen_winInfo != nullptr);
1285
1286 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1287 infos.emplace_back(rosen_winInfo);
1288
1289 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1290 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1291 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1292 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1293 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1294 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1295
1296 /* GetAccessibilityWindow */
1297 bool window = mgr.GetAccessibilityWindow(windowId, info);
1298 EXPECT_TRUE(window);
1299
1300 mgr.a11yWindows_.clear();
1301 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow001 end";
1302 }
1303
1304 /**
1305 * @tc.number: AccessibilityWindowManager_Unittest_GetAccessibilityWindow002
1306 * @tc.name: GetAccessibilityWindow
1307 * @tc.desc: Test function GetAccessibilityWindow
1308 */
1309 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetAccessibilityWindow002, TestSize.Level1)
1310 {
1311 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow002 start";
1312 /* map insert value */
1313 int32_t windowId = ANY_WINDOW_ID;
1314
1315 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1316 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1317 EXPECT_TRUE(rosen_winInfo != nullptr);
1318
1319 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1320 infos.emplace_back(rosen_winInfo);
1321
1322 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1323 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1324 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1325 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1326 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1327 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1328
1329 /* GetAccessibilityWindow */
1330 bool window = mgr.GetAccessibilityWindow(-1, info);
1331 EXPECT_FALSE(window);
1332
1333 mgr.a11yWindows_.clear();
1334 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetAccessibilityWindow002 end";
1335 }
1336
1337 /**
1338 * @tc.number: AccessibilityWindowManager_Unittest_IsValidWindow001
1339 * @tc.name: IsValidWindow
1340 * @tc.desc: Test function IsValidWindow
1341 */
1342 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_IsValidWindow001, TestSize.Level1)
1343 {
1344 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow001 start";
1345 /* map insert value */
1346 int32_t windowId = ANY_WINDOW_ID;
1347
1348 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1349 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1350 EXPECT_TRUE(rosen_winInfo != nullptr);
1351
1352 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1353 infos.emplace_back(rosen_winInfo);
1354
1355 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1356 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1357 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1358 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1359 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1360 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1361
1362 /* IsValidWindow */
1363 bool window = mgr.IsValidWindow(windowId);
1364 EXPECT_TRUE(window);
1365
1366 mgr.a11yWindows_.clear();
1367 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow001 end";
1368 }
1369
1370 /**
1371 * @tc.number: AccessibilityWindowManager_Unittest_IsValidWindow002
1372 * @tc.name: IsValidWindow
1373 * @tc.desc: Test function IsValidWindow
1374 */
1375 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_IsValidWindow002, TestSize.Level1)
1376 {
1377 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow002 start";
1378 /* map insert value */
1379 int32_t windowId = ANY_WINDOW_ID;
1380
1381 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1382 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1383 EXPECT_TRUE(rosen_winInfo != nullptr);
1384
1385 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1386 infos.emplace_back(rosen_winInfo);
1387
1388 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1389 AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
1390 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1391 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1392 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1393 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1394
1395 /* IsValidWindow */
1396 bool window = mgr.IsValidWindow(0);
1397 EXPECT_FALSE(window);
1398
1399 mgr.a11yWindows_.clear();
1400 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsValidWindow002 end";
1401 }
1402
1403 /**
1404 * @tc.number: AccessibilityWindowManager_Unittest_SetWindowSize001
1405 * @tc.name: SetActiveWindow
1406 * @tc.desc: Test function SetActiveWindow
1407 */
1408 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_SetWindowSize001, TestSize.Level1)
1409 {
1410 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetWindowSize001 start";
1411 /* map insert value */
1412 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1413 int32_t windowId = ANY_WINDOW_ID;
1414 AccessibilityWindowInfo info;
1415 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1416 mgr.a11yWindows_.insert(std::make_pair(windowId, info));
1417 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1418
1419 /* SetWindowSize */
1420 Rect rect(1, 2, 3, 4);
1421 mgr.SetWindowSize(windowId, rect);
1422 AccessibilityWindowInfo mapInfo;
1423 for (auto& window : mgr.a11yWindows_) {
1424 mapInfo = window.second;
1425 }
1426 EXPECT_EQ(rect.GetLeftTopXScreenPostion(), mapInfo.GetRectInScreen().GetLeftTopXScreenPostion());
1427 EXPECT_EQ(rect.GetRightBottomXScreenPostion(), mapInfo.GetRectInScreen().GetRightBottomXScreenPostion());
1428
1429 mgr.a11yWindows_.clear();
1430 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_SetWindowSize001 end";
1431 }
1432
1433 /**
1434 * @tc.number: AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001
1435 * @tc.name: ClearAccessibilityFocused
1436 * @tc.desc: Test function ClearAccessibilityFocused
1437 */
1438 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001,
1439 TestSize.Level1)
1440 {
1441 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001 start";
1442 /* map insert value */
1443 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1444 AccessibilityWindowInfo info1;
1445 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1446 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1447 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1448
1449 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(true);
1450 /* ClearAccessibilityFocused */
1451 mgr.ClearAccessibilityFocused();
1452 AccessibilityAbilityHelper::GetInstance().SetNeedAccountDataNullFlag(false);
1453 /* test */
1454 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1455 mgr.a11yWindows_.clear();
1456 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused001 end";
1457 }
1458
1459 /**
1460 * @tc.number: AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002
1461 * @tc.name: ClearAccessibilityFocused
1462 * @tc.desc: Test function ClearAccessibilityFocused
1463 */
1464 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002,
1465 TestSize.Level1)
1466 {
1467 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002 start";
1468 /* map insert value */
1469 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1470 AccessibilityWindowInfo info1;
1471 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1472 EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
1473 mgr.a11yWindows_.insert(std::make_pair(ACTIVE_WINDOW_ID, info1));
1474 sptr<AccessibilityAccountData> accountData =
1475 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1476 if (!accountData) {
1477 GTEST_LOG_(INFO) << "accountData is null";
1478 return;
1479 }
1480 sptr<AccessibilityWindowConnection> windowConnection =
1481 new(std::nothrow) AccessibilityWindowConnection(ACTIVE_WINDOW_ID, nullptr, ACCOUNT_ID);
1482 accountData->RemoveAccessibilityWindowConnection(ACTIVE_WINDOW_ID);
1483 accountData->AddAccessibilityWindowConnection(ACTIVE_WINDOW_ID, windowConnection);
1484 /* ClearAccessibilityFocused */
1485 mgr.ClearAccessibilityFocused();
1486 /* test */
1487 EXPECT_EQ(1, (int)mgr.a11yWindows_.size());
1488 mgr.a11yWindows_.clear();
1489 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused002 end";
1490 }
1491
1492 /**
1493 * @tc.number: AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003
1494 * @tc.name: ClearAccessibilityFocused
1495 * @tc.desc: Test function ClearAccessibilityFocused
1496 */
1497 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003,
1498 TestSize.Level1)
1499 {
1500 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003 start";
1501 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1502 mgr.a11yFocusedWindowId_ = ACTIVE_WINDOW_ID;
1503 sptr<AccessibilityAccountData> accountData =
1504 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1505 if (!accountData) {
1506 GTEST_LOG_(INFO) << "accountData is null";
1507 return;
1508 }
1509 sptr<IAccessibilityElementOperator> proxy = new(std::nothrow) AccessibilityElementOperatorProxy(nullptr);
1510 sptr<AccessibilityWindowConnection> windowConnection =
1511 new(std::nothrow) AccessibilityWindowConnection(ACTIVE_WINDOW_ID, proxy, ACCOUNT_ID);
1512 accountData->RemoveAccessibilityWindowConnection(ACTIVE_WINDOW_ID);
1513 accountData->AddAccessibilityWindowConnection(ACTIVE_WINDOW_ID, windowConnection);
1514 /* ClearAccessibilityFocused */
1515 mgr.ClearAccessibilityFocused();
1516 /* test */
1517 AccessibilityAbilityHelper::GetInstance().SetEventWindowId(ACTIVE_WINDOW_ID);
1518 EXPECT_EQ(ACTIVE_WINDOW_ID, AccessibilityAbilityHelper::GetInstance().GetEventWindowId());
1519 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_ClearAccessibilityFocused003 end";
1520 }
1521
1522 /**
1523 * @tc.number: AccessibilityWindowManager_Unittest_DeregisterWindowListener001
1524 * @tc.name: RegisterWindowListener
1525 * @tc.desc: Test function RegisterWindowListener
1526 */
1527 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_DeregisterWindowListener001,
1528 TestSize.Level1)
1529 {
1530 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener001 start";
1531
1532 Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener();
1533
1534 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener001 end";
1535 }
1536
1537 /**
1538 * @tc.number: AccessibilityWindowManager_Unittest_DeregisterWindowListener002
1539 * @tc.name: RegisterWindowListener
1540 * @tc.desc: Test function RegisterWindowListener
1541 */
1542 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_DeregisterWindowListener002,
1543 TestSize.Level1)
1544 {
1545 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener002 start";
1546
1547 const std::string AAMS_SERVICE_NAME = "AccessibleAbilityManagerService";
1548 std::shared_ptr<AppExecFwk::EventRunner> runner_ =
1549 AppExecFwk::EventRunner::Create(AAMS_SERVICE_NAME, AppExecFwk::ThreadMode::FFRT);
1550 std::shared_ptr<AppExecFwk::EventHandler> handler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
1551
1552 Singleton<AccessibilityWindowManager>::GetInstance().RegisterWindowListener(handler_);
1553 Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener();
1554
1555 EXPECT_NE(handler_, nullptr);
1556
1557 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeregisterWindowListener002 end";
1558 }
1559
1560 /**
1561 * @tc.number: AccessibilityWindowManager_Unittest_DeInit001
1562 * @tc.name: DeInit
1563 * @tc.desc: Test function DeInit
1564 */
1565 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_DeInit001, TestSize.Level1)
1566 {
1567 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeInit001 start";
1568 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1569 int32_t windowId = WINDOW_ID;
1570 AccessibilityWindowInfo winInfo;
1571
1572 windowInfoManager.activeWindowId_ = windowId;
1573 windowInfoManager.a11yFocusedWindowId_ = windowId;
1574 windowInfoManager.a11yWindows_.emplace(windowId, winInfo);
1575 windowInfoManager.DeInit();
1576
1577 EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
1578 EXPECT_EQ(windowInfoManager.a11yFocusedWindowId_, INVALID_WINDOW_ID);
1579 EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
1580 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_DeInit001 end";
1581 }
1582
1583 /**
1584 * @tc.number: AccessibilityWindowManager_Unittest_Init001
1585 * @tc.name: Init
1586 * @tc.desc: Test function Init
1587 */
1588 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_Init001, TestSize.Level1)
1589 {
1590 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_Init001 start";
1591 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1592 int32_t windowId = WINDOW_ID;
1593 AccessibilityWindowInfo winInfo;
1594
1595 windowInfoManager.activeWindowId_ = windowId;
1596 windowInfoManager.a11yFocusedWindowId_ = windowId;
1597 windowInfoManager.a11yWindows_.emplace(windowId, winInfo);
1598 EXPECT_EQ(1, (int)windowInfoManager.a11yWindows_.size());
1599
1600 int32_t windowId1 = ACTIVE_WINDOW_ID;
1601 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
1602 Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
1603 EXPECT_TRUE(rosen_winInfo != nullptr);
1604
1605 AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
1606 info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
1607 windowInfoManager.a11yWindows_.insert(std::make_pair(windowId1, info));
1608 EXPECT_EQ(2, (int)windowInfoManager.a11yWindows_.size());
1609
1610 /* SetAccessibilityFocusedWindow */
1611 windowInfoManager.SetAccessibilityFocusedWindow(windowId1);
1612 EXPECT_EQ(windowInfoManager.a11yFocusedWindowId_, ACTIVE_WINDOW_ID);
1613
1614 bool result = windowInfoManager.Init();
1615 EXPECT_EQ(result, true);
1616
1617 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_Init001 end";
1618 }
1619
1620 /**
1621 * @tc.number: AccessibilityWindowManager_Unittest_GetRealWindowAndElementId001
1622 * @tc.name: GetRealWindowAndElementId
1623 * @tc.desc: Test function GetRealWindowAndElementId
1624 */
1625 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetRealWindowAndElementId001,
1626 TestSize.Level1)
1627 {
1628 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetRealWindowAndElementId001 start";
1629 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
1630 EXPECT_TRUE(rosen_winInfo != nullptr);
1631 rosen_winInfo->wid_ = 1;
1632 rosen_winInfo->innerWid_ = INNER_WINDOW_ID;
1633 rosen_winInfo->uiNodeId_ = INNER_ELEMENT_ID;
1634
1635 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1636 windowInfoManager.a11yWindows_.clear();
1637 windowInfoManager.subWindows_.clear();
1638 windowInfoManager.a11yWindows_.insert(std::make_pair(rosen_winInfo->innerWid_,
1639 windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo)));
1640 windowInfoManager.subWindows_.insert(rosen_winInfo->innerWid_);
1641
1642 int32_t windowId = INNER_WINDOW_ID;
1643 int64_t elementId = INVALID_ELEMENT_ID;
1644 windowInfoManager.GetRealWindowAndElementId(windowId, elementId);
1645 EXPECT_EQ(windowId, 1);
1646 EXPECT_EQ(elementId, INNER_ELEMENT_ID);
1647
1648 windowId = INNER_WINDOW_ID;
1649 elementId = 0;
1650 windowInfoManager.GetRealWindowAndElementId(windowId, elementId);
1651 EXPECT_EQ(windowId, 1);
1652 EXPECT_NE(elementId, INNER_ELEMENT_ID);
1653 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetRealWindowAndElementId001 end";
1654 }
1655
1656 /**
1657 * @tc.number: AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId001
1658 * @tc.name: GetSceneBoardInnerWinId
1659 * @tc.desc: Test function GetSceneBoardInnerWinId
1660 */
1661 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId001,
1662 TestSize.Level1)
1663 {
1664 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId001 start";
1665 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
1666 EXPECT_TRUE(rosen_winInfo != nullptr);
1667 rosen_winInfo->wid_ = 1;
1668 rosen_winInfo->innerWid_ = INNER_WINDOW_ID;
1669 rosen_winInfo->uiNodeId_ = INNER_ELEMENT_ID;
1670
1671 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1672 windowInfoManager.a11yWindows_.clear();
1673 windowInfoManager.subWindows_.clear();
1674 windowInfoManager.a11yWindows_.insert(std::make_pair(rosen_winInfo->innerWid_,
1675 windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo)));
1676 windowInfoManager.subWindows_.insert(rosen_winInfo->innerWid_);
1677
1678 int32_t windowId = 1;
1679 int64_t elementId = INNER_ELEMENT_ID;
1680 int32_t innerWid = 0;
1681 windowInfoManager.GetSceneBoardInnerWinId(windowId, elementId, innerWid);
1682 EXPECT_EQ(innerWid, INNER_WINDOW_ID);
1683 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId001 end";
1684 }
1685
1686 /**
1687 * @tc.number: AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId002
1688 * @tc.name: GetSceneBoardInnerWinId
1689 * @tc.desc: Test function GetSceneBoardInnerWinId
1690 */
1691 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId002,
1692 TestSize.Level1)
1693 {
1694 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId002 start";
1695 sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
1696 EXPECT_TRUE(rosen_winInfo != nullptr);
1697 rosen_winInfo->wid_ = 1;
1698 rosen_winInfo->innerWid_ = INNER_WINDOW_ID;
1699 rosen_winInfo->uiNodeId_ = INNER_ELEMENT_ID;
1700
1701 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1702 windowInfoManager.a11yWindows_.clear();
1703 windowInfoManager.subWindows_.clear();
1704 windowInfoManager.a11yWindows_.insert(std::make_pair(rosen_winInfo->innerWid_,
1705 windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo)));
1706 windowInfoManager.subWindows_.insert(rosen_winInfo->innerWid_);
1707
1708 int32_t windowId = 2;
1709 int64_t elementId = INNER_ELEMENT_ID;
1710 int32_t innerWid = 0;
1711 windowInfoManager.GetSceneBoardInnerWinId(windowId, elementId, innerWid);
1712 EXPECT_NE(innerWid, INNER_WINDOW_ID);
1713 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardInnerWinId002 end";
1714 }
1715
1716 /**
1717 * @tc.number: AccessibilityWindowManager_Unittest_GetFocusedWindowId001
1718 * @tc.name: GetFocusedWindowId
1719 * @tc.desc: Test function GetFocusedWindowId
1720 */
1721 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetFocusedWindowId001,
1722 TestSize.Level1)
1723 {
1724 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetFocusedWindowId001 start";
1725 int32_t windowId = 1;
1726 RetError ret = Singleton<AccessibilityWindowManager>::GetInstance().GetFocusedWindowId(windowId);
1727 EXPECT_EQ(ret, RET_OK);
1728
1729 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetFocusedWindowId001 end";
1730 }
1731
1732 /**
1733 * @tc.number: AccessibilityWindowManager_Unittest_IsInnerWindowRootElement001
1734 * @tc.name: IsInnerWindowRootElement
1735 * @tc.desc: Test function IsInnerWindowRootElement
1736 */
1737 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_IsInnerWindowRootElement001,
1738 TestSize.Level1)
1739 {
1740 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsInnerWindowRootElement001 start";
1741 int32_t windowId = INNER_WINDOW_ID;
1742 int64_t elementId = INVALID_ELEMENT_ID;
1743 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1744 mgr.sceneBoardElementIdMap_.Clear();
1745
1746 EXPECT_FALSE(mgr.IsInnerWindowRootElement(elementId));
1747 mgr.sceneBoardElementIdMap_.InsertPair(windowId, elementId);
1748
1749 EXPECT_TRUE(mgr.IsInnerWindowRootElement(elementId));
1750 mgr.sceneBoardElementIdMap_.Clear();
1751 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_IsInnerWindowRootElement001 end";
1752 }
1753
1754 /**
1755 * @tc.number: AccessibilityWindowManager_Unittest_GetSceneBoardElementId001
1756 * @tc.name: GetSceneBoardElementId
1757 * @tc.desc: Test function GetSceneBoardElementId
1758 */
1759 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetSceneBoardElementId001, TestSize.Level1)
1760 {
1761 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardElementId001 start";
1762 int32_t windowId = ANY_WINDOW_ID;
1763 int32_t elementId = INVALID_ELEMENT_ID;
1764 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1765 mgr.subWindows_.clear();
1766 int32_t sceneBoardElementId = mgr.GetSceneBoardElementId(windowId, elementId);
1767 ASSERT_TRUE(sceneBoardElementId == elementId);
1768 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardElementId001 end";
1769 }
1770
1771 /**
1772 * @tc.number: AccessibilityWindowManager_Unittest_GetSceneBoardElementId002
1773 * @tc.name: GetSceneBoardElementId
1774 * @tc.desc: Test function GetSceneBoardElementId
1775 */
1776 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_GetSceneBoardElementId002, TestSize.Level1)
1777 {
1778 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardElementId002 start";
1779 int32_t windowId = ANY_WINDOW_ID;
1780 int32_t elementId = INVALID_SCENE_BOARD_ELEMENT_ID;
1781 AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
1782 mgr.subWindows_.clear();
1783 int32_t sceneBoardElementId = mgr.GetSceneBoardElementId(windowId, elementId);
1784 ASSERT_TRUE(sceneBoardElementId == elementId);
1785 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_GetSceneBoardElementId002 end";
1786 }
1787
1788 /**
1789 * @tc.number: AccessibilityWindowManager_Unittest_OnWindowUpdate001
1790 * @tc.name: OnWindowUpdate
1791 * @tc.desc: Test function OnWindowUpdate
1792 */
1793 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowUpdate001, TestSize.Level1)
1794 {
1795 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowUpdate001 start";
1796
1797 AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
1798 std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
1799 infos.emplace_back(nullptr);
1800 windowInfoManager.RegisterWindowListener(nullptr);
1801 windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE);
1802 sleep(1);
1803 ASSERT_TRUE(windowInfoManager.a11yWindows_.size() != 0);
1804 windowInfoManager.a11yWindows_.clear();
1805 GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowUpdate001 end";
1806 }
1807 } // namespace Accessibility
1808 } // namespace OHOS
1809